vidpipe 1.3.6 → 1.3.7

package/dist/cli.js

@@ -316,7 +316,9 @@ function initConfig(cli = {}) {
     LATE_PROFILE_ID: cli.lateProfileId || process.env.LATE_PROFILE_ID || "",
     SKIP_SOCIAL_PUBLISH: cli.socialPublish === false,
     GEMINI_API_KEY: process.env.GEMINI_API_KEY || "",
-    GEMINI_MODEL: process.env.GEMINI_MODEL || "gemini-2.5-pro"
+    GEMINI_MODEL: process.env.GEMINI_MODEL || "gemini-2.5-pro",
+    IDEAS_REPO: cli.ideasRepo || process.env.IDEAS_REPO || "htekdev/content-management",
+    GITHUB_TOKEN: cli.githubToken || process.env.GITHUB_TOKEN || ""
   };
   return config;
 }
@@ -402,6 +404,54 @@ var init_configLogger = __esm({
   }
 });
 
+// src/L0-pure/types/index.ts
+function toLatePlatform(platform) {
+  return platform === "x" /* X */ ? "twitter" : platform;
+}
+function fromLatePlatform(latePlatform) {
+  const normalized = normalizePlatformString(latePlatform);
+  if (normalized === "twitter") {
+    return "x" /* X */;
+  }
+  const platformValues2 = Object.values(Platform);
+  if (platformValues2.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Unsupported platform from Late API: ${latePlatform}`);
+}
+function normalizePlatformString(raw) {
+  const lower = raw.toLowerCase().trim();
+  if (lower === "x" || lower === "x (twitter)" || lower === "x/twitter") {
+    return "twitter";
+  }
+  return lower;
+}
+function isSupportedVideoExtension(ext) {
+  return SUPPORTED_VIDEO_EXTENSIONS.includes(ext.toLowerCase());
+}
+var Platform, PLATFORM_CHAR_LIMITS, SUPPORTED_VIDEO_EXTENSIONS;
+var init_types = __esm({
+  "src/L0-pure/types/index.ts"() {
+    "use strict";
+    Platform = /* @__PURE__ */ ((Platform2) => {
+      Platform2["TikTok"] = "tiktok";
+      Platform2["YouTube"] = "youtube";
+      Platform2["Instagram"] = "instagram";
+      Platform2["LinkedIn"] = "linkedin";
+      Platform2["X"] = "x";
+      return Platform2;
+    })(Platform || {});
+    PLATFORM_CHAR_LIMITS = {
+      tiktok: 2200,
+      youtube: 5e3,
+      instagram: 2200,
+      linkedin: 3e3,
+      twitter: 280
+    };
+    SUPPORTED_VIDEO_EXTENSIONS = [".mp4", ".webm"];
+  }
+});
+
 // src/L0-pure/pricing/pricing.ts
 function calculateTokenCost(model, inputTokens, outputTokens) {
   const pricing = getModelPricing(model);
@@ -1187,151 +1237,870 @@ var init_modelConfig = __esm({
   }
 });
 
-// src/L1-infra/ideaStore/ideaStore.ts
-function resolveIdeasDir(dir) {
-  return dir ? resolve(dir) : DEFAULT_IDEAS_DIR;
+// src/L2-clients/github/githubClient.ts
+import { Octokit } from "octokit";
+function getErrorStatus(error) {
+  if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") {
+    return error.status;
+  }
+  return void 0;
 }
 function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message ?? "Unknown GitHub API error";
+  }
+  return String(error);
+}
+function normalizeLabels(labels) {
+  return Array.from(new Set(labels.map((label) => label.trim()).filter((label) => label.length > 0)));
 }
-function validateIdeaId(id) {
-  if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(id)) {
-    throw new Error(`Invalid idea ID: ${id}`);
+function isIssueResponse(value) {
+  return !("pull_request" in value);
+}
+function getGitHubClient() {
+  const config2 = getConfig();
+  const nextKey = `${config2.IDEAS_REPO}:${config2.GITHUB_TOKEN}`;
+  if (!clientInstance || clientKey !== nextKey) {
+    clientInstance = new GitHubClient(config2.GITHUB_TOKEN, config2.IDEAS_REPO);
+    clientKey = nextKey;
   }
-  return id;
+  return clientInstance;
 }
-function getIdeaFilePath(id, dir) {
-  return join(resolveIdeasDir(dir), `${validateIdeaId(id)}${IDEA_FILE_EXTENSION}`);
+var DEFAULT_PER_PAGE, GitHubClientError, GitHubClient, clientInstance, clientKey;
+var init_githubClient = __esm({
+  "src/L2-clients/github/githubClient.ts"() {
+    "use strict";
+    init_environment();
+    init_configLogger();
+    DEFAULT_PER_PAGE = 100;
+    GitHubClientError = class extends Error {
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "GitHubClientError";
+      }
+    };
+    GitHubClient = class {
+      octokit;
+      owner;
+      repo;
+      constructor(token, repoFullName) {
+        const config2 = getConfig();
+        const authToken = token || config2.GITHUB_TOKEN;
+        if (!authToken) {
+          throw new Error("GITHUB_TOKEN is required for GitHub API access");
+        }
+        const fullName = repoFullName || config2.IDEAS_REPO;
+        const [owner, repo] = fullName.split("/").map((part) => part.trim());
+        if (!owner || !repo) {
+          throw new Error(`Invalid IDEAS_REPO format: "${fullName}" \u2014 expected "owner/repo"`);
+        }
+        this.owner = owner;
+        this.repo = repo;
+        this.octokit = new Octokit({ auth: authToken });
+      }
+      async createIssue(input) {
+        logger_default.debug(`[GitHubClient] Creating issue in ${this.owner}/${this.repo}: ${input.title}`);
+        try {
+          const response = await this.octokit.rest.issues.create({
+            owner: this.owner,
+            repo: this.repo,
+            title: input.title,
+            body: input.body,
+            labels: input.labels ? normalizeLabels(input.labels) : void 0
+          });
+          const issue = this.mapIssue(response.data);
+          logger_default.info(`[GitHubClient] Created issue #${issue.number}: ${input.title}`);
+          return issue;
+        } catch (error) {
+          this.logError("create issue", error);
+          throw new GitHubClientError(`Failed to create GitHub issue: ${getErrorMessage(error)}`, getErrorStatus(error));
+        }
+      }
+      async updateIssue(issueNumber, input) {
+        logger_default.debug(`[GitHubClient] Updating issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          const response = await this.octokit.rest.issues.update({
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber,
+            title: input.title,
+            body: input.body,
+            state: input.state,
+            labels: input.labels ? normalizeLabels(input.labels) : void 0
+          });
+          return this.mapIssue(response.data);
+        } catch (error) {
+          this.logError(`update issue #${issueNumber}`, error);
+          throw new GitHubClientError(
+            `Failed to update GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
+            getErrorStatus(error)
+          );
+        }
+      }
+      async getIssue(issueNumber) {
+        logger_default.debug(`[GitHubClient] Fetching issue #${issueNumber} from ${this.owner}/${this.repo}`);
+        try {
+          const response = await this.octokit.rest.issues.get({
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber
+          });
+          return this.mapIssue(response.data);
+        } catch (error) {
+          this.logError(`get issue #${issueNumber}`, error);
+          throw new GitHubClientError(
+            `Failed to fetch GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
+            getErrorStatus(error)
+          );
+        }
+      }
+      async listIssues(options = {}) {
+        logger_default.debug(`[GitHubClient] Listing issues for ${this.owner}/${this.repo}`);
+        const issues = [];
+        let page;
+        const maxResults = options.maxResults ?? Number.POSITIVE_INFINITY;
+        try {
+          while (issues.length < maxResults) {
+            const response = await this.octokit.rest.issues.listForRepo({
+              owner: this.owner,
+              repo: this.repo,
+              state: "open",
+              labels: options.labels && options.labels.length > 0 ? normalizeLabels(options.labels).join(",") : void 0,
+              sort: void 0,
+              direction: void 0,
+              per_page: DEFAULT_PER_PAGE,
+              page
+            });
+            const pageItems = response.data.filter(isIssueResponse).map((issue) => this.mapIssue(issue));
+            issues.push(...pageItems);
+            if (pageItems.length < DEFAULT_PER_PAGE) {
+              break;
+            }
+            page = (page ?? 1) + 1;
+          }
+          return issues.slice(0, maxResults);
+        } catch (error) {
+          this.logError("list issues", error);
+          throw new GitHubClientError(`Failed to list GitHub issues: ${getErrorMessage(error)}`, getErrorStatus(error));
+        }
+      }
+      async searchIssues(query, options = {}) {
+        const searchQuery = `repo:${this.owner}/${this.repo} is:issue ${query}`.trim();
+        logger_default.debug(`[GitHubClient] Searching issues in ${this.owner}/${this.repo}: ${query}`);
+        try {
+          const items = await this.octokit.paginate(this.octokit.rest.search.issuesAndPullRequests, {
+            q: searchQuery,
+            per_page: DEFAULT_PER_PAGE
+          });
+          return items.filter(isIssueResponse).map((issue) => this.mapIssue(issue)).slice(0, options.maxResults ?? Number.POSITIVE_INFINITY);
+        } catch (error) {
+          this.logError("search issues", error);
+          throw new GitHubClientError(`Failed to search GitHub issues: ${getErrorMessage(error)}`, getErrorStatus(error));
+        }
+      }
+      async addLabels(issueNumber, labels) {
+        if (labels.length === 0) {
+          return;
+        }
+        logger_default.debug(`[GitHubClient] Adding labels to issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          await this.octokit.rest.issues.addLabels({
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber,
+            labels
+          });
+        } catch (error) {
+          this.logError(`add labels to issue #${issueNumber}`, error);
+          throw new GitHubClientError(
+            `Failed to add labels to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
+            getErrorStatus(error)
+          );
+        }
+      }
+      async removeLabel(issueNumber, label) {
+        logger_default.debug(`[GitHubClient] Removing label "${label}" from issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          await this.octokit.rest.issues.removeLabel({
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber,
+            name: label
+          });
+        } catch (error) {
+          if (getErrorStatus(error) === 404) {
+            return;
+          }
+          this.logError(`remove label from issue #${issueNumber}`, error);
+          throw new GitHubClientError(
+            `Failed to remove label from GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
+            getErrorStatus(error)
+          );
+        }
+      }
+      async setLabels(issueNumber, labels) {
+        logger_default.debug(`[GitHubClient] Setting labels on issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          await this.octokit.rest.issues.setLabels({
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber,
+            labels
+          });
+        } catch (error) {
+          this.logError(`set labels on issue #${issueNumber}`, error);
+          throw new GitHubClientError(
+            `Failed to set labels on GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
+            getErrorStatus(error)
+          );
+        }
+      }
+      async addComment(issueNumber, body) {
+        logger_default.debug(`[GitHubClient] Adding comment to issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          const response = await this.octokit.rest.issues.createComment({
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber,
+            body
+          });
+          return this.mapComment(response.data);
+        } catch (error) {
+          this.logError(`add comment to issue #${issueNumber}`, error);
+          throw new GitHubClientError(
+            `Failed to add comment to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
+            getErrorStatus(error)
+          );
+        }
+      }
+      async listComments(issueNumber) {
+        logger_default.debug(`[GitHubClient] Listing comments for issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          const comments = await this.octokit.paginate(this.octokit.rest.issues.listComments, {
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber,
+            per_page: DEFAULT_PER_PAGE
+          });
+          return comments.map((comment) => this.mapComment(comment));
+        } catch (error) {
+          this.logError(`list comments for issue #${issueNumber}`, error);
+          throw new GitHubClientError(
+            `Failed to list comments for GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
+            getErrorStatus(error)
+          );
+        }
+      }
+      mapIssue(issue) {
+        return {
+          number: issue.number,
+          title: issue.title,
+          body: issue.body ?? "",
+          state: issue.state,
+          labels: issue.labels.map((label) => typeof label === "string" ? label : label.name ?? "").map((label) => label.trim()).filter((label) => label.length > 0),
+          created_at: issue.created_at,
+          updated_at: issue.updated_at,
+          html_url: issue.html_url
+        };
+      }
+      mapComment(comment) {
+        return {
+          id: comment.id,
+          body: comment.body ?? "",
+          created_at: comment.created_at,
+          updated_at: comment.updated_at,
+          html_url: comment.html_url
+        };
+      }
+      logError(action, error) {
+        logger_default.error(`[GitHubClient] Failed to ${action} in ${this.owner}/${this.repo}: ${getErrorMessage(error)}`);
+      }
+    };
+    clientInstance = null;
+    clientKey = "";
+  }
+});
+
+// src/L3-services/ideaService/ideaService.ts
+var ideaService_exports = {};
+__export(ideaService_exports, {
+  createIdea: () => createIdea,
+  findRelatedIdeas: () => findRelatedIdeas,
+  getIdea: () => getIdea,
+  getPublishHistory: () => getPublishHistory,
+  getReadyIdeas: () => getReadyIdeas,
+  linkVideoToIdea: () => linkVideoToIdea,
+  listIdeas: () => listIdeas,
+  markPublished: () => markPublished,
+  markRecorded: () => markRecorded,
+  recordPublish: () => recordPublish,
+  searchIdeas: () => searchIdeas,
+  updateIdea: () => updateIdea
+});
+function getErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
+function sanitizeMultilineValue(value) {
+  return (value ?? "").trim();
 }
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
+function normalizeTag(tag) {
+  return tag.trim().toLowerCase().replace(/\s+/g, "-");
 }
-function isIdeaStatus(value) {
-  return typeof value === "string" && ideaStatuses.has(value);
+function normalizeTags(tags) {
+  return Array.from(new Set(tags.map((tag) => normalizeTag(tag)).filter((tag) => tag.length > 0)));
 }
 function isPlatform(value) {
-  return typeof value === "string" && ideaPlatforms.has(value);
+  return platformValues.has(value);
 }
-function isPlatformArray(value) {
-  return Array.isArray(value) && value.every((item) => isPlatform(item));
-}
-function isValidIsoDateString(value) {
-  return typeof value === "string" && !Number.isNaN(new Date(value).getTime());
+function isIdeaStatus(value) {
+  return ideaStatuses.has(value);
 }
-function isIdeaPublishRecord(value) {
-  return isRecord(value) && typeof value.queueItemId === "string" && typeof value.publishedAt === "string" && typeof value.clipType === "string" && ideaClipTypes.has(value.clipType) && isPlatform(value.platform) && (value.publishedUrl === void 0 || typeof value.publishedUrl === "string");
+function uniquePlatforms(platforms) {
+  return Array.from(new Set(platforms));
 }
-function isIdea(value) {
-  return isRecord(value) && typeof value.id === "string" && typeof value.topic === "string" && typeof value.hook === "string" && typeof value.audience === "string" && typeof value.keyTakeaway === "string" && isStringArray(value.talkingPoints) && isPlatformArray(value.platforms) && isIdeaStatus(value.status) && isStringArray(value.tags) && typeof value.createdAt === "string" && typeof value.updatedAt === "string" && isValidIsoDateString(value.publishBy) && (value.sourceVideoSlug === void 0 || typeof value.sourceVideoSlug === "string") && (value.trendContext === void 0 || typeof value.trendContext === "string") && (value.publishedContent === void 0 || Array.isArray(value.publishedContent) && value.publishedContent.every((item) => isIdeaPublishRecord(item)));
+function classifyIdeaPriority(publishBy, createdAtIso) {
+  const publishByTimestamp = new Date(publishBy).getTime();
+  const createdAtTimestamp = new Date(createdAtIso).getTime();
+  if (Number.isNaN(publishByTimestamp) || Number.isNaN(createdAtTimestamp)) {
+    return "evergreen";
+  }
+  const diffDays = Math.ceil((publishByTimestamp - createdAtTimestamp) / (1e3 * 60 * 60 * 24));
+  if (diffDays <= 7) {
+    return "hot-trend";
+  }
+  if (diffDays <= 14) {
+    return "timely";
+  }
+  return "evergreen";
 }
-async function readIdeaBank(dir) {
-  const ideasDir = resolveIdeasDir(dir);
-  const ideaIds = await listIdeaIds(ideasDir);
-  const ideas = await Promise.all(
-    ideaIds.map(async (id) => {
-      try {
-        return await readIdea(id, ideasDir);
-      } catch (error) {
-        logger_default.warn(`Skipping invalid idea file ${id}${IDEA_FILE_EXTENSION}: ${getErrorMessage(error)}`);
-        return null;
+function extractLabelsFromIdea(idea, publishBy, createdAtIso) {
+  const labels = [
+    `${STATUS_LABEL_PREFIX}${idea.status}`,
+    ...uniquePlatforms(idea.platforms).map((platform) => `${PLATFORM_LABEL_PREFIX}${platform}`),
+    `${PRIORITY_LABEL_PREFIX}${classifyIdeaPriority(publishBy, createdAtIso)}`,
+    ...normalizeTags(idea.tags)
+  ];
+  return Array.from(new Set(labels));
+}
+function parseLabelsToIdea(labels) {
+  let status = "draft";
+  const platforms = [];
+  const tags = [];
+  for (const label of labels) {
+    const normalized = label.trim().toLowerCase();
+    if (!normalized) {
+      continue;
+    }
+    if (normalized.startsWith(STATUS_LABEL_PREFIX)) {
+      const value = normalized.slice(STATUS_LABEL_PREFIX.length);
+      if (isIdeaStatus(value)) {
+        status = value;
       }
-    })
-  );
-  return ideas.filter((idea) => idea !== null);
+      continue;
+    }
+    if (normalized.startsWith(PLATFORM_LABEL_PREFIX)) {
+      const value = normalized.slice(PLATFORM_LABEL_PREFIX.length);
+      if (isPlatform(value)) {
+        platforms.push(value);
+      }
+      continue;
+    }
+    if (normalized.startsWith(PRIORITY_LABEL_PREFIX)) {
+      continue;
+    }
+    tags.push(normalized);
+  }
+  return {
+    status,
+    platforms: uniquePlatforms(platforms),
+    tags: Array.from(new Set(tags))
+  };
 }
-async function writeIdea(idea, dir) {
-  const ideasDir = resolveIdeasDir(dir);
-  const ideaPath = getIdeaFilePath(idea.id, ideasDir);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (!isValidIsoDateString(idea.publishBy)) {
-    throw new Error(`Invalid publishBy date: ${idea.publishBy}`);
+function formatIdeaBody(input) {
+  const sections = [
+    `${MARKDOWN_SECTION_PREFIX}Hook`,
+    sanitizeMultilineValue(input.hook),
+    "",
+    `${MARKDOWN_SECTION_PREFIX}Audience`,
+    sanitizeMultilineValue(input.audience),
+    "",
+    `${MARKDOWN_SECTION_PREFIX}Key Takeaway`,
+    sanitizeMultilineValue(input.keyTakeaway),
+    "",
+    `${MARKDOWN_SECTION_PREFIX}Talking Points`,
+    ...input.talkingPoints.map((point) => `- ${sanitizeMultilineValue(point)}`),
+    "",
+    `${MARKDOWN_SECTION_PREFIX}Publish By`,
+    sanitizeMultilineValue(input.publishBy)
+  ];
+  const trendContext = sanitizeMultilineValue(input.trendContext);
+  if (trendContext) {
+    sections.push("", `${MARKDOWN_SECTION_PREFIX}Trend Context`, trendContext);
+  }
+  return sections.join("\n").trim();
+}
+function parseIdeaBody(body, fallbackPublishBy) {
+  const normalizedBody = body.replace(/\r\n/g, "\n");
+  const sections = /* @__PURE__ */ new Map();
+  let currentSection = null;
+  for (const line of normalizedBody.split("\n")) {
+    if (line.startsWith(MARKDOWN_SECTION_PREFIX)) {
+      currentSection = line.slice(MARKDOWN_SECTION_PREFIX.length).trim();
+      sections.set(currentSection, []);
+      continue;
+    }
+    if (currentSection) {
+      sections.get(currentSection)?.push(line);
+    }
   }
-  idea.updatedAt = now;
-  await ensureDirectory(ideasDir);
-  await writeJsonFile(ideaPath, idea);
+  const getSection = (heading) => (sections.get(heading) ?? []).join("\n").trim();
+  const talkingPointsSection = sections.get("Talking Points") ?? [];
+  const talkingPoints = talkingPointsSection.map((line) => line.trim()).filter((line) => line.startsWith("- ") || line.startsWith("* ")).map((line) => line.slice(2).trim()).filter((line) => line.length > 0);
+  return {
+    hook: getSection("Hook"),
+    audience: getSection("Audience"),
+    keyTakeaway: getSection("Key Takeaway"),
+    talkingPoints,
+    publishBy: getSection("Publish By") || fallbackPublishBy,
+    trendContext: getSection("Trend Context") || void 0
+  };
+}
+function formatIdeaComment(data) {
+  return [
+    COMMENT_MARKER,
+    "```json",
+    JSON.stringify(data, null, 2),
+    "```"
+  ].join("\n");
+}
+function formatPublishRecordComment(record) {
+  return [
+    "Published content recorded for this idea.",
+    "",
+    `- Clip type: ${record.clipType}`,
+    `- Platform: ${record.platform}`,
+    `- Queue item: ${record.queueItemId}`,
+    `- Published at: ${record.publishedAt}`,
+    `- Late post ID: ${record.latePostId}`,
+    `- Late URL: ${record.lateUrl}`,
+    "",
+    formatIdeaComment({ type: "publish-record", record })
+  ].join("\n");
+}
+function formatVideoLinkComment(videoSlug, linkedAt) {
+  return [
+    "Linked a source video to this idea.",
+    "",
+    `- Video slug: ${videoSlug}`,
+    `- Linked at: ${linkedAt}`,
+    "",
+    formatIdeaComment({ type: "video-link", videoSlug, linkedAt })
+  ].join("\n");
 }
-async function readIdea(id, dir) {
-  const ideaPath = getIdeaFilePath(id, dir);
-  if (!await fileExists(ideaPath)) {
+function parseIdeaComment(commentBody) {
+  const markerIndex = commentBody.indexOf(COMMENT_MARKER);
+  if (markerIndex === -1) {
     return null;
   }
-  const idea = await readJsonFile(ideaPath);
-  if (!isIdea(idea)) {
-    throw new Error(`File does not contain a valid idea: ${ideaPath}`);
+  const commentPayload = commentBody.slice(markerIndex + COMMENT_MARKER.length);
+  const fencedJsonMatch = commentPayload.match(/```json\s*([\s\S]*?)\s*```/);
+  const jsonText = fencedJsonMatch?.[1]?.trim() ?? commentPayload.trim();
+  if (!jsonText) {
+    return null;
   }
-  return idea;
+  try {
+    const parsed = JSON.parse(jsonText);
+    if (parsed.type === "video-link" && typeof parsed.videoSlug === "string" && typeof parsed.linkedAt === "string") {
+      return {
+        type: "video-link",
+        videoSlug: parsed.videoSlug,
+        linkedAt: parsed.linkedAt
+      };
+    }
+    if (parsed.type === "publish-record" && parsed.record) {
+      const record = parsed.record;
+      if (typeof record.clipType === "string" && typeof record.platform === "string" && isPlatform(record.platform) && typeof record.queueItemId === "string" && typeof record.publishedAt === "string" && typeof record.latePostId === "string" && typeof record.lateUrl === "string") {
+        return {
+          type: "publish-record",
+          record: {
+            clipType: record.clipType,
+            platform: record.platform,
+            queueItemId: record.queueItemId,
+            publishedAt: record.publishedAt,
+            latePostId: record.latePostId,
+            lateUrl: record.lateUrl
+          }
+        };
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
 }
-async function listIdeaIds(dir) {
-  const ideasDir = resolveIdeasDir(dir);
-  if (!await fileExists(ideasDir)) {
+function buildLabelFilters(filters) {
+  if (!filters) {
     return [];
   }
-  const entries = await listDirectory(ideasDir);
-  return entries.filter((entry) => entry.toLowerCase().endsWith(IDEA_FILE_EXTENSION)).map((entry) => entry.slice(0, -IDEA_FILE_EXTENSION.length));
+  const labels = [];
+  if (filters.status) {
+    labels.push(`${STATUS_LABEL_PREFIX}${filters.status}`);
+  }
+  if (filters.platform) {
+    labels.push(`${PLATFORM_LABEL_PREFIX}${filters.platform}`);
+  }
+  if (filters.tag) {
+    labels.push(normalizeTag(filters.tag));
+  }
+  if (filters.priority) {
+    labels.push(`${PRIORITY_LABEL_PREFIX}${filters.priority}`);
+  }
+  return labels;
+}
+function buildLabelsFromIssue(issue, overrides = {}) {
+  const parsedLabels = parseLabelsToIdea(issue.labels);
+  const parsedBody = parseIdeaBody(issue.body, issue.created_at.slice(0, 10));
+  return extractLabelsFromIdea(
+    {
+      status: overrides.status ?? parsedLabels.status,
+      platforms: overrides.platforms ?? parsedLabels.platforms,
+      tags: overrides.tags ?? parsedLabels.tags
+    },
+    parsedBody.publishBy,
+    issue.created_at
+  );
+}
+function isNotFoundError(error) {
+  return error instanceof GitHubClientError && error.status === 404;
+}
+function mapIssueToIdea(issue, comments) {
+  const config2 = getConfig();
+  const parsedLabels = parseLabelsToIdea(issue.labels);
+  const parsedBody = parseIdeaBody(issue.body, issue.created_at.slice(0, 10));
+  const publishRecords = [];
+  let sourceVideoSlug;
+  for (const comment of comments) {
+    const parsedComment = parseIdeaComment(comment.body);
+    if (!parsedComment) {
+      continue;
+    }
+    if (parsedComment.type === "publish-record") {
+      publishRecords.push(parsedComment.record);
+      continue;
+    }
+    sourceVideoSlug = parsedComment.videoSlug;
+  }
+  return {
+    issueNumber: issue.number,
+    issueUrl: issue.html_url,
+    repoFullName: config2.IDEAS_REPO,
+    id: `idea-${issue.number}`,
+    topic: issue.title,
+    ...parsedBody,
+    ...parsedLabels,
+    createdAt: issue.created_at,
+    updatedAt: issue.updated_at,
+    sourceVideoSlug,
+    publishedContent: publishRecords.length > 0 ? publishRecords : void 0
+  };
+}
+async function createIdea(input) {
+  const client = getGitHubClient();
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const issue = await client.createIssue({
+      title: input.topic,
+      body: formatIdeaBody(input),
+      labels: extractLabelsFromIdea(
+        {
+          status: "draft",
+          platforms: input.platforms,
+          tags: input.tags
+        },
+        input.publishBy,
+        createdAt
+      )
+    });
+    logger_default.info(`[IdeaService] Created idea #${issue.number}: ${input.topic}`);
+    return mapIssueToIdea(issue, []);
+  } catch (error) {
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to create idea "${input.topic}": ${message}`);
+    throw new Error(`Failed to create idea "${input.topic}": ${message}`);
+  }
+}
+async function updateIdea(issueNumber, updates) {
+  const client = getGitHubClient();
+  try {
+    const currentIdea = await getIdea(issueNumber);
+    if (!currentIdea) {
+      throw new Error(`Idea #${issueNumber} was not found`);
+    }
+    const nextInput = {
+      topic: updates.topic ?? currentIdea.topic,
+      hook: updates.hook ?? currentIdea.hook,
+      audience: updates.audience ?? currentIdea.audience,
+      keyTakeaway: updates.keyTakeaway ?? currentIdea.keyTakeaway,
+      talkingPoints: updates.talkingPoints ?? currentIdea.talkingPoints,
+      platforms: updates.platforms ?? currentIdea.platforms,
+      tags: updates.tags ?? currentIdea.tags,
+      publishBy: updates.publishBy ?? currentIdea.publishBy,
+      trendContext: updates.trendContext ?? currentIdea.trendContext
+    };
+    const shouldUpdateBody = updates.hook !== void 0 || updates.audience !== void 0 || updates.keyTakeaway !== void 0 || updates.talkingPoints !== void 0 || updates.publishBy !== void 0 || updates.trendContext !== void 0;
+    const shouldUpdateLabels = updates.status !== void 0 || updates.platforms !== void 0 || updates.tags !== void 0 || updates.publishBy !== void 0;
+    const issue = await client.updateIssue(issueNumber, {
+      title: updates.topic,
+      body: shouldUpdateBody ? formatIdeaBody(nextInput) : void 0,
+      labels: shouldUpdateLabels ? extractLabelsFromIdea(
+        {
+          status: updates.status ?? currentIdea.status,
+          platforms: nextInput.platforms,
+          tags: nextInput.tags
+        },
+        nextInput.publishBy,
+        currentIdea.createdAt
+      ) : void 0
+    });
+    const comments = await client.listComments(issueNumber);
+    return mapIssueToIdea(issue, comments);
+  } catch (error) {
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to update idea #${issueNumber}: ${message}`);
+    throw new Error(`Failed to update idea #${issueNumber}: ${message}`);
+  }
+}
+async function getIdea(issueNumber) {
+  const client = getGitHubClient();
+  try {
+    const [issue, comments] = await Promise.all([
+      client.getIssue(issueNumber),
+      client.listComments(issueNumber)
+    ]);
+    return mapIssueToIdea(issue, comments);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return null;
+    }
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to get idea #${issueNumber}: ${message}`);
+    throw new Error(`Failed to get idea #${issueNumber}: ${message}`);
+  }
+}
+async function listIdeas(filters) {
+  const client = getGitHubClient();
+  try {
+    const issues = await client.listIssues({
+      labels: buildLabelFilters(filters),
+      maxResults: filters?.limit
+    });
+    const ideas = await Promise.all(
+      issues.map(async (issue) => {
+        const comments = await client.listComments(issue.number);
+        return mapIssueToIdea(issue, comments);
+      })
+    );
+    return filters?.limit ? ideas.slice(0, filters.limit) : ideas;
+  } catch (error) {
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to list ideas: ${message}`);
+    throw new Error(`Failed to list ideas: ${message}`);
+  }
+}
+async function searchIdeas(query) {
+  const client = getGitHubClient();
+  try {
+    const issues = await client.searchIssues(query);
+    return await Promise.all(
+      issues.map(async (issue) => {
+        const comments = await client.listComments(issue.number);
+        return mapIssueToIdea(issue, comments);
+      })
+    );
+  } catch (error) {
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to search ideas: ${message}`);
+    throw new Error(`Failed to search ideas: ${message}`);
+  }
+}
+async function findRelatedIdeas(idea) {
+  const client = getGitHubClient();
+  try {
+    const relatedIssues = /* @__PURE__ */ new Map();
+    for (const tag of normalizeTags(idea.tags)) {
+      const matches = await client.listIssues({ labels: [tag], maxResults: 5 });
+      for (const match of matches) {
+        if (match.number !== idea.issueNumber) {
+          relatedIssues.set(match.number, match);
+        }
+      }
+    }
+    const sortedIssues = Array.from(relatedIssues.values()).sort((left, right) => right.updated_at.localeCompare(left.updated_at)).slice(0, 5);
+    return await Promise.all(
+      sortedIssues.map(async (issue) => {
+        const comments = await client.listComments(issue.number);
+        return mapIssueToIdea(issue, comments);
+      })
+    );
+  } catch (error) {
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to find related ideas for #${idea.issueNumber}: ${message}`);
+    throw new Error(`Failed to find related ideas for #${idea.issueNumber}: ${message}`);
+  }
+}
+async function linkVideoToIdea(issueNumber, videoSlug) {
+  const client = getGitHubClient();
+  try {
+    const [issue] = await Promise.all([
+      client.getIssue(issueNumber),
+      client.addComment(issueNumber, formatVideoLinkComment(videoSlug, (/* @__PURE__ */ new Date()).toISOString()))
+    ]);
+    await client.updateIssue(issueNumber, {
+      labels: buildLabelsFromIssue(issue, { status: "recorded" })
+    });
+  } catch (error) {
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to link video ${videoSlug} to idea #${issueNumber}: ${message}`);
+    throw new Error(`Failed to link video ${videoSlug} to idea #${issueNumber}: ${message}`);
+  }
+}
+async function recordPublish(issueNumber, record) {
+  const client = getGitHubClient();
+  try {
+    const [issue, comments] = await Promise.all([
+      client.getIssue(issueNumber),
+      client.listComments(issueNumber)
+    ]);
+    const hasDuplicate = comments.some((comment) => {
+      const parsedComment = parseIdeaComment(comment.body);
+      return parsedComment?.type === "publish-record" && parsedComment.record.queueItemId === record.queueItemId;
+    });
+    if (!hasDuplicate) {
+      await client.addComment(issueNumber, formatPublishRecordComment(record));
+    }
+    if (!issue.labels.includes(`${STATUS_LABEL_PREFIX}published`)) {
+      await client.updateIssue(issueNumber, {
+        labels: buildLabelsFromIssue(issue, { status: "published" })
+      });
+    }
+  } catch (error) {
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to record publish for idea #${issueNumber}: ${message}`);
+    throw new Error(`Failed to record publish for idea #${issueNumber}: ${message}`);
+  }
+}
+async function getPublishHistory(issueNumber) {
+  const client = getGitHubClient();
+  try {
+    const comments = await client.listComments(issueNumber);
+    return comments.flatMap((comment) => {
+      const parsedComment = parseIdeaComment(comment.body);
+      return parsedComment?.type === "publish-record" ? [parsedComment.record] : [];
+    });
+  } catch (error) {
+    const message = getErrorMessage2(error);
+    logger_default.error(`[IdeaService] Failed to get publish history for idea #${issueNumber}: ${message}`);
+    throw new Error(`Failed to get publish history for idea #${issueNumber}: ${message}`);
+  }
 }
-var DEFAULT_IDEAS_DIR, IDEA_FILE_EXTENSION, ideaStatuses, ideaClipTypes, ideaPlatforms;
-var init_ideaStore = __esm({
-  "src/L1-infra/ideaStore/ideaStore.ts"() {
+async function getReadyIdeas() {
+  return listIdeas({ status: "ready" });
+}
+async function markRecorded(issueNumber, videoSlug) {
+  await linkVideoToIdea(issueNumber, videoSlug);
+}
+async function markPublished(issueNumber, record) {
+  await recordPublish(issueNumber, record);
+}
+var STATUS_LABEL_PREFIX, PLATFORM_LABEL_PREFIX, PRIORITY_LABEL_PREFIX, COMMENT_MARKER, MARKDOWN_SECTION_PREFIX, platformValues, ideaStatuses;
+var init_ideaService = __esm({
+  "src/L3-services/ideaService/ideaService.ts"() {
     "use strict";
-    init_fileSystem();
+    init_types();
+    init_githubClient();
+    init_environment();
     init_configLogger();
-    init_paths();
-    DEFAULT_IDEAS_DIR = join(resolve("."), "ideas");
-    IDEA_FILE_EXTENSION = ".json";
+    STATUS_LABEL_PREFIX = "status:";
+    PLATFORM_LABEL_PREFIX = "platform:";
+    PRIORITY_LABEL_PREFIX = "priority:";
+    COMMENT_MARKER = "<!-- vidpipe:idea-comment -->";
+    MARKDOWN_SECTION_PREFIX = "## ";
+    platformValues = new Set(Object.values(Platform));
     ideaStatuses = /* @__PURE__ */ new Set(["draft", "ready", "recorded", "published"]);
-    ideaClipTypes = /* @__PURE__ */ new Set(["video", "short", "medium-clip"]);
-    ideaPlatforms = /* @__PURE__ */ new Set(["tiktok", "youtube", "instagram", "linkedin", "x"]);
   }
 });
 
 // src/L3-services/ideation/ideaService.ts
-var ideaService_exports = {};
-__export(ideaService_exports, {
+var ideaService_exports2 = {};
+__export(ideaService_exports2, {
   getIdeasByIds: () => getIdeasByIds,
-  getReadyIdeas: () => getReadyIdeas,
-  markPublished: () => markPublished,
-  markRecorded: () => markRecorded,
+  getReadyIdeas: () => getReadyIdeas2,
+  markPublished: () => markPublished2,
+  markRecorded: () => markRecorded2,
   matchIdeasToTranscript: () => matchIdeasToTranscript
 });
-async function getIdeasByIds(ids, dir) {
-  return Promise.all(
-    ids.map(async (id) => {
-      const idea = await readIdea(id, dir);
-      if (!idea) {
-        throw new Error(`Idea not found: ${id}`);
-      }
+function normalizeIdeaIdentifier(id) {
+  return id.trim();
+}
+function buildIdeaLookup(ideas) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const idea of ideas) {
+    lookup.set(idea.id, idea);
+    lookup.set(String(idea.issueNumber), idea);
+  }
+  return lookup;
+}
+async function resolveIdeaByIdentifier(id, ideas) {
+  const normalizedId = normalizeIdeaIdentifier(id);
+  if (!normalizedId) {
+    return null;
+  }
+  const issueNumber = Number.parseInt(normalizedId, 10);
+  if (Number.isInteger(issueNumber)) {
+    const idea = await getIdea(issueNumber);
+    if (idea) {
       return idea;
-    })
-  );
+    }
+  }
+  const availableIdeas = ideas ?? await listIdeas();
+  return buildIdeaLookup(availableIdeas).get(normalizedId) ?? null;
+}
+async function getIdeasByIds(ids, _dir) {
+  const ideas = await listIdeas();
+  const lookup = buildIdeaLookup(ideas);
+  return ids.map((id) => {
+    const normalizedId = normalizeIdeaIdentifier(id);
+    const idea = lookup.get(normalizedId);
+    if (!idea) {
+      throw new Error(`Idea not found: ${id}`);
+    }
+    return idea;
+  });
 }
-async function getReadyIdeas(dir) {
-  const ideas = await readIdeaBank(dir);
-  return ideas.filter((idea) => idea.status === "ready");
+async function getReadyIdeas2(_dir) {
+  return getReadyIdeas();
 }
-async function markRecorded(id, videoSlug, dir) {
-  const idea = await readIdea(id, dir);
+async function markRecorded2(id, videoSlug, _dir) {
+  const idea = await resolveIdeaByIdentifier(id);
   if (!idea) {
     throw new Error(`Idea not found: ${id}`);
   }
-  idea.status = "recorded";
-  idea.sourceVideoSlug = videoSlug;
-  await writeIdea(idea, dir);
+  await markRecorded(idea.issueNumber, videoSlug);
 }
-async function markPublished(id, record, dir) {
-  const idea = await readIdea(id, dir);
+async function markPublished2(id, record, _dir) {
+  const idea = await resolveIdeaByIdentifier(id);
   if (!idea) {
     throw new Error(`Idea not found: ${id}`);
   }
-  idea.publishedContent = [...idea.publishedContent ?? [], record];
-  idea.status = "published";
-  await writeIdea(idea, dir);
+  await markPublished(idea.issueNumber, record);
 }
-async function matchIdeasToTranscript(transcript, ideas, dir) {
+async function matchIdeasToTranscript(transcript, ideas, _dir) {
   try {
-    const readyIdeas = (ideas ?? await readIdeaBank(dir)).filter((idea) => idea.status === "ready");
+    const readyIdeas = (ideas ?? await getReadyIdeas()).filter((idea) => idea.status === "ready");
     if (readyIdeas.length === 0) {
       return [];
     }
@@ -1349,9 +2118,7 @@ async function matchIdeasToTranscript(transcript, ideas, dir) {
       hook: idea.hook,
       keyTakeaway: idea.keyTakeaway
     }));
-    const knownIdeaIds = new Set(
-      ideas ? readyIdeaIds : await listIdeaIds(dir)
-    );
+    const knownIdeaIds = readyIdeaIds;
     const session = await provider.createSession({
       systemPrompt: MATCH_IDEAS_SYSTEM_PROMPT,
       tools: [],
@@ -1370,7 +2137,7 @@ async function matchIdeasToTranscript(transcript, ideas, dir) {
           return matchedIdea ? [matchedIdea] : [];
         });
       }
-      return await getIdeasByIds(matchedIds, dir);
+      return await getIdeasByIds(matchedIds);
     } finally {
       await session.close().catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
@@ -1403,12 +2170,12 @@ function parseMatchedIdeaIds(rawContent, knownIdeaIds) {
   return Array.from(new Set(matchedIds.filter((id) => knownIdeaIds.has(id))));
 }
 var IDEA_MATCH_AGENT_NAME, IDEA_MATCH_LIMIT, TRANSCRIPT_SUMMARY_LIMIT, MATCH_IDEAS_SYSTEM_PROMPT;
-var init_ideaService = __esm({
+var init_ideaService2 = __esm({
   "src/L3-services/ideation/ideaService.ts"() {
     "use strict";
     init_modelConfig();
-    init_ideaStore();
     init_configLogger();
+    init_ideaService();
     init_providerFactory();
     IDEA_MATCH_AGENT_NAME = "IdeaService";
     IDEA_MATCH_LIMIT = 3;
@@ -1440,50 +2207,7 @@ init_environment();
 init_paths();
 init_fileSystem();
 init_configLogger();
-
-// src/L0-pure/types/index.ts
-var Platform = /* @__PURE__ */ ((Platform2) => {
-  Platform2["TikTok"] = "tiktok";
-  Platform2["YouTube"] = "youtube";
-  Platform2["Instagram"] = "instagram";
-  Platform2["LinkedIn"] = "linkedin";
-  Platform2["X"] = "x";
-  return Platform2;
-})(Platform || {});
-var PLATFORM_CHAR_LIMITS = {
-  tiktok: 2200,
-  youtube: 5e3,
-  instagram: 2200,
-  linkedin: 3e3,
-  twitter: 280
-};
-function toLatePlatform(platform) {
-  return platform === "x" /* X */ ? "twitter" : platform;
-}
-function fromLatePlatform(latePlatform) {
-  const normalized = normalizePlatformString(latePlatform);
-  if (normalized === "twitter") {
-    return "x" /* X */;
-  }
-  const platformValues = Object.values(Platform);
-  if (platformValues.includes(normalized)) {
-    return normalized;
-  }
-  throw new Error(`Unsupported platform from Late API: ${latePlatform}`);
-}
-function normalizePlatformString(raw) {
-  const lower = raw.toLowerCase().trim();
-  if (lower === "x" || lower === "x (twitter)" || lower === "x/twitter") {
-    return "twitter";
-  }
-  return lower;
-}
-var SUPPORTED_VIDEO_EXTENSIONS = [".mp4", ".webm"];
-function isSupportedVideoExtension(ext) {
-  return SUPPORTED_VIDEO_EXTENSIONS.includes(ext.toLowerCase());
-}
-
-// src/L7-app/fileWatcher.ts
+init_types();
 var FileWatcher = class _FileWatcher extends EventEmitter {
   watchFolder;
   watcher = null;
@@ -4449,6 +5173,7 @@ var SocialPostAsset = class extends TextAsset {
 // src/L5-assets/ShortVideoAsset.ts
 init_paths();
 init_fileSystem();
+init_types();
 var ShortVideoAsset = class extends VideoAsset {
   /** Reference to the source video this short was extracted from */
   parent;
@@ -4581,6 +5306,7 @@ var ShortVideoAsset = class extends VideoAsset {
 // src/L5-assets/MediumClipAsset.ts
 init_paths();
 init_fileSystem();
+init_types();
 var MediumClipAsset = class extends VideoAsset {
   /** Parent video this clip was extracted from */
   parent;
@@ -6780,6 +7506,7 @@ init_fileSystem();
 init_paths();
 init_configLogger();
 init_environment();
+init_types();
 var SYSTEM_PROMPT5 = `You are a viral social-media content strategist.
 Given a video transcript and summary you MUST generate one post for each of the 5 platforms listed below.
 Each post must match the platform's tone, format, and constraints exactly.
@@ -7291,8 +8018,11 @@ async function commitAndPush(videoSlug, message) {
 init_fileSystem();
 init_paths();
 init_configLogger();
+init_types();
+init_types();
 
 // src/L3-services/socialPosting/platformContentStrategy.ts
+init_types();
 var CONTENT_MATRIX = {
   ["youtube" /* YouTube */]: {
     video: { captions: true, variantKey: null },
@@ -7325,6 +8055,7 @@ function platformAcceptsMedia(platform, clipType) {
 }
 
 // src/L3-services/postStore/postStore.ts
+init_types();
 init_environment();
 init_configLogger();
 init_fileSystem();
@@ -7533,14 +8264,40 @@ async function approveItem(id, publishData) {
   item.metadata.reviewedAt = now;
   if (item.metadata.ideaIds && item.metadata.ideaIds.length > 0) {
     try {
-      const { markPublished: markPublished2 } = await Promise.resolve().then(() => (init_ideaService(), ideaService_exports));
-      for (const ideaId of item.metadata.ideaIds) {
-        await markPublished2(ideaId, {
+      const { getIdea: getIdea2, listIdeas: listIdeas2, markPublished: markPublished3 } = await Promise.resolve().then(() => (init_ideaService(), ideaService_exports));
+      let cachedIdeas;
+      for (const rawIdeaId of item.metadata.ideaIds) {
+        const normalizedIdeaId = String(rawIdeaId).trim();
+        if (!normalizedIdeaId) {
+          continue;
+        }
+        const parsedIssueNumber = Number.parseInt(normalizedIdeaId, 10);
+        let issueNumber;
+        if (Number.isInteger(parsedIssueNumber)) {
+          issueNumber = parsedIssueNumber;
+        } else {
+          if (!cachedIdeas) {
+            const ideas = await listIdeas2();
+            cachedIdeas = new Map(ideas.flatMap((idea2) => [[idea2.id, idea2.issueNumber], [String(idea2.issueNumber), idea2.issueNumber]]));
+          }
+          issueNumber = cachedIdeas.get(normalizedIdeaId);
+        }
+        if (!issueNumber) {
+          logger_default.warn(`Skipping publish record for unknown idea identifier: ${normalizedIdeaId}`);
+          continue;
+        }
+        const idea = await getIdea2(issueNumber);
+        if (!idea) {
+          logger_default.warn(`Skipping publish record for missing idea #${issueNumber}`);
+          continue;
+        }
+        await markPublished3(issueNumber, {
           clipType: item.metadata.clipType,
           platform: fromLatePlatform(item.metadata.platform),
           queueItemId: id,
           publishedAt: now,
-          publishedUrl: item.metadata.publishedUrl ?? void 0
+          latePostId: item.metadata.latePostId ?? "",
+          lateUrl: item.metadata.publishedUrl || (item.metadata.latePostId ? `https://app.late.co/dashboard/post/${item.metadata.latePostId}` : "")
         });
       }
     } catch (err) {
@@ -8127,6 +8884,7 @@ async function enhanceVideo(videoPath, transcript, video) {
 // src/L5-assets/MainVideoAsset.ts
 init_environment();
 init_configLogger();
+init_types();
 var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   sourcePath;
   videoDir;
@@ -9013,7 +9771,7 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
    */
   async buildPublishQueueData(shorts, mediumClips, socialPosts, captionedVideoPath) {
     const video = await this.toVideoFile();
-    const ideaIds = this._ideas.length > 0 ? this._ideas.map((idea) => idea.id) : void 0;
+    const ideaIds = this._ideas.length > 0 ? this._ideas.map((idea) => String(idea.issueNumber)) : void 0;
     return buildPublishQueue2(video, shorts, mediumClips, socialPosts, captionedVideoPath, ideaIds);
   }
   /**
@@ -10733,17 +11491,26 @@ var ScheduleAgent = class extends BaseAgent {
 init_fileSystem();
 init_environment();
 init_modelConfig();
-init_ideaStore();
 init_configLogger();
+init_ideaService();
 init_providerFactory();
+init_types();
 var BASE_SYSTEM_PROMPT = `You are a content strategist for a tech content creator. Your role is to research trending topics, analyze what's working, and generate compelling video ideas grounded in real-world data.
 
 ## CRITICAL: Research Before Creating
 You MUST research before creating ideas. Do NOT skip the research phase. Ideas generated without research will be generic and stale. The value you provide is grounding ideas in what's ACTUALLY trending right now.
 
+## GitHub Issue Workflow
+Ideas are stored as GitHub Issues in a dedicated repository. Treat the issue tracker as the source of truth:
+- Use get_past_ideas to inspect the current issue backlog with optional filters.
+- Use search_ideas for full-text lookups before creating something new.
+- Use find_related_ideas to cluster overlapping ideas by tags and avoid duplicates.
+- Use create_idea to create new draft issues.
+- Use update_idea or organize_ideas when an existing issue should be refined instead of creating a duplicate.
+
 ## Your Research Process
 1. Load the brand context (get_brand_context) to understand the creator's voice, expertise, and content pillars.
-2. Check existing ideas (get_past_ideas) to avoid duplicates.
+2. Check existing GitHub issue ideas (get_past_ideas and search_ideas) to avoid duplicates.
 3. **RESEARCH PHASE** \u2014 This is the most important step. Use the available MCP tools:
    - **web_search_exa**: Search for trending topics, viral content, recent announcements, and hot takes in the creator's niche. Search for specific topics from the creator's content pillars.
    - **youtube_search_videos** or **youtube_search**: Find what videos are performing well right now. Look at view counts, recent uploads on trending topics, and gaps in existing content.
@@ -10769,15 +11536,27 @@ Every idea must:
 - Written (LinkedIn, X/Twitter): Thought leadership, hot takes, thread-worthy
 
 Generate 3-5 high-quality ideas. Quality over quantity. Every idea must be backed by research.`;
-var SUPPORTED_PLATFORMS = ["tiktok", "youtube", "instagram", "linkedin", "x"];
+var SUPPORTED_PLATFORMS = [
+  "tiktok" /* TikTok */,
+  "youtube" /* YouTube */,
+  "instagram" /* Instagram */,
+  "linkedin" /* LinkedIn */,
+  "x" /* X */
+];
+var SUPPORTED_STATUSES = ["draft", "ready", "recorded", "published"];
+var SUPPORTED_PRIORITIES = ["hot-trend", "timely", "evergreen"];
 var MIN_IDEA_COUNT = 3;
 var MAX_IDEA_COUNT = 5;
-function isRecord2(value) {
+var DEFAULT_EXISTING_IDEA_LIMIT = 50;
+function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
-function isStringArray2(value) {
+function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+function hasField(source, field) {
+  return Object.prototype.hasOwnProperty.call(source, field);
+}
 function normalizeCount(count) {
   if (typeof count !== "number" || Number.isNaN(count)) {
     return MIN_IDEA_COUNT;
@@ -10790,7 +11569,7 @@ function normalizeSeedTopics(seedTopics) {
 }
 function extractStringArrayField(source, field) {
   const value = source[field];
-  return isStringArray2(value) ? value : [];
+  return isStringArray(value) ? value : [];
 }
 function extractContentPillars(brand) {
   const raw = brand.contentPillars;
@@ -10802,7 +11581,7 @@ function extractContentPillars(brand) {
       const pillar2 = entry.trim();
       return pillar2 ? [{ pillar: pillar2 }] : [];
     }
-    if (!isRecord2(entry)) {
+    if (!isRecord(entry)) {
       return [];
     }
     const pillar = typeof entry.pillar === "string" ? entry.pillar.trim() : "";
@@ -10811,21 +11590,22 @@ function extractContentPillars(brand) {
     }
     const description = typeof entry.description === "string" ? entry.description.trim() : void 0;
     const frequency = typeof entry.frequency === "string" ? entry.frequency.trim() : void 0;
-    const formats = isStringArray2(entry.formats) ? entry.formats.map((format) => format.trim()).filter((format) => format.length > 0) : void 0;
+    const formats = isStringArray(entry.formats) ? entry.formats.map((format) => format.trim()).filter((format) => format.length > 0) : void 0;
     return [{ pillar, description, frequency, formats }];
   });
 }
 function summarizeExistingIdeas(ideas) {
   if (ideas.length === 0) {
-    return "No existing ideas found in the bank.";
+    return "No existing GitHub issue ideas found in the repository.";
   }
-  return ideas.slice(0, 25).map((idea) => `- ${idea.id}: ${idea.topic} [${idea.status}]`).join("\n");
+  return ideas.slice(0, 25).map((idea) => `- #${idea.issueNumber}: ${idea.topic} [${idea.status}] (${idea.issueUrl})`).join("\n");
 }
 function buildPlatformGuidance() {
   return [
     `Allowed platforms for create_idea: ${SUPPORTED_PLATFORMS.join(", ")}`,
     `Create between ${MIN_IDEA_COUNT} and ${MAX_IDEA_COUNT} ideas unless the user explicitly requests fewer within that range.`,
-    "Call create_idea once per idea, then call finalize_ideas exactly once when done."
+    "Call create_idea once per new idea issue, then call finalize_ideas exactly once when done.",
+    "Prefer update_idea or organize_ideas when you discover that a GitHub issue already covers the concept."
   ].join("\n");
 }
 function buildBrandPromptSection(brand) {
@@ -10859,20 +11639,33 @@ function buildBrandPromptSection(brand) {
     lines.push("Content pillars:");
     lines.push(
       ...contentPillars.map((pillar) => {
-        const details = [pillar.description, pillar.frequency && `Frequency: ${pillar.frequency}`, pillar.formats?.length ? `Formats: ${pillar.formats.join(", ")}` : void 0].filter((value) => typeof value === "string" && value.length > 0).join(" | ");
+        const details = [
+          pillar.description,
+          pillar.frequency && `Frequency: ${pillar.frequency}`,
+          pillar.formats?.length ? `Formats: ${pillar.formats.join(", ")}` : void 0
+        ].filter((value) => typeof value === "string" && value.length > 0).join(" | ");
         return details ? `- ${pillar.pillar}: ${details}` : `- ${pillar.pillar}`;
       })
     );
   }
   return lines.join("\n");
 }
-function buildSystemPrompt3(brand, existingIdeas, seedTopics, count) {
+function buildIdeaRepoPromptSection(ideaRepo) {
+  return [
+    "## GitHub Idea Repository",
+    `Dedicated issue repo: ${ideaRepo}`,
+    "Every idea is a GitHub Issue. The issue tracker is the source of truth for duplicates, lifecycle status, tags, and related concepts."
+  ].join("\n");
+}
+function buildSystemPrompt3(brand, existingIdeas, seedTopics, count, ideaRepo) {
   const promptSections = [
     BASE_SYSTEM_PROMPT,
     "",
+    buildIdeaRepoPromptSection(ideaRepo),
+    "",
     buildBrandPromptSection(brand),
     "",
-    "## Existing Idea Bank",
+    "## Existing Idea Issues",
     summarizeExistingIdeas(existingIdeas),
     "",
     "## Planning Constraints",
@@ -10888,7 +11681,7 @@ function buildUserMessage(count, seedTopics, hasMcpServers) {
   const focusText = seedTopics.length > 0 ? `Focus areas: ${seedTopics.join(", ")}` : "Focus areas: choose the strongest timely opportunities from the creator context and current trends.";
   const steps = [
     "1. Call get_brand_context to load the creator profile.",
-    "2. Call get_past_ideas to see what already exists."
+    "2. Call get_past_ideas (and search_ideas if needed) to inspect existing GitHub issue ideas before proposing anything new."
   ];
   if (hasMcpServers) {
     steps.push(
@@ -10898,12 +11691,14 @@ function buildUserMessage(count, seedTopics, hasMcpServers) {
       "   - Use perplexity-search to get current analysis on promising topics.",
       "   Do at least 2-3 research queries. Each idea you create MUST reference specific findings from this research in its trendContext field.",
       `4. Call create_idea for each of the ${count} ideas, grounding each in your research findings.`,
-      "5. Call finalize_ideas when done."
+      "5. If you uncover overlap with existing issues, prefer update_idea or organize_ideas over creating duplicates.",
+      "6. Call finalize_ideas when done."
     );
   } else {
     steps.push(
       `3. Call create_idea for each of the ${count} ideas.`,
-      "4. Call finalize_ideas when done."
+      "4. If you uncover overlap with existing issues, prefer update_idea or organize_ideas over creating duplicates.",
+      "5. Call finalize_ideas when done."
     );
   }
   return [
@@ -10920,50 +11715,181 @@ async function loadBrandContext(brandPath) {
   }
   return readJsonFile(brandPath);
 }
-function normalizePlatforms(platforms) {
-  const normalized = platforms.map((platform) => platform.trim().toLowerCase());
-  const invalid = normalized.filter((platform) => !SUPPORTED_PLATFORMS.includes(platform));
-  if (invalid.length > 0) {
-    throw new Error(`Unsupported platforms: ${invalid.join(", ")}`);
+function normalizeRequiredString(value, field) {
+  if (typeof value !== "string") {
+    throw new Error(`Invalid ${field}: expected string`);
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`Invalid ${field}: value cannot be empty`);
   }
   return normalized;
 }
-function assertKebabCaseId(id) {
-  const normalized = id.trim();
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(normalized)) {
-    throw new Error(`Idea ID must be kebab-case: ${id}`);
+function normalizeOptionalString(value, field) {
+  if (value === void 0) {
+    return void 0;
   }
-  return normalized;
+  if (typeof value !== "string") {
+    throw new Error(`Invalid ${field}: expected string`);
+  }
+  const normalized = value.trim();
+  return normalized || void 0;
 }
-function buildIdea(args) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const publishBy = args.publishBy.trim();
-  if (args.hook.trim().length > 80) {
-    throw new Error(`Idea hook must be 80 characters or fewer: ${args.id}`);
+function normalizeStringList(value, field) {
+  if (!isStringArray(value)) {
+    throw new Error(`Invalid ${field}: expected string[]`);
   }
+  return value.map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function normalizeIssueNumber(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new Error("Invalid issueNumber: expected a positive integer");
+  }
+  return value;
+}
+function normalizePublishBy(value, field = "publishBy") {
+  const publishBy = normalizeRequiredString(value, field);
   if (Number.isNaN(new Date(publishBy).getTime())) {
-    throw new Error(`Invalid publishBy date: ${args.publishBy}`);
+    throw new Error(`Invalid ${field} date: ${publishBy}`);
+  }
+  return publishBy;
+}
+function normalizePlatforms(platforms) {
+  const values = normalizeStringList(platforms, "platforms").map((platform) => platform.toLowerCase());
+  const invalid = values.filter((platform) => !SUPPORTED_PLATFORMS.includes(platform));
+  if (invalid.length > 0) {
+    throw new Error(`Unsupported platforms: ${invalid.join(", ")}`);
+  }
+  return values;
+}
+function normalizeStatus(value) {
+  const status = normalizeRequiredString(value, "status").toLowerCase();
+  if (!SUPPORTED_STATUSES.includes(status)) {
+    throw new Error(`Unsupported status: ${status}`);
+  }
+  return status;
+}
+function parseCreateIdeaInput(args) {
+  const hook = normalizeRequiredString(args.hook, "hook");
+  if (hook.length > 80) {
+    throw new Error(`Idea hook must be 80 characters or fewer: ${hook}`);
   }
   return {
-    id: assertKebabCaseId(args.id),
-    topic: args.topic.trim(),
-    hook: args.hook.trim(),
-    audience: args.audience.trim(),
-    keyTakeaway: args.keyTakeaway.trim(),
-    talkingPoints: args.talkingPoints.map((point) => point.trim()).filter((point) => point.length > 0),
+    topic: normalizeRequiredString(args.topic, "topic"),
+    hook,
+    audience: normalizeRequiredString(args.audience, "audience"),
+    keyTakeaway: normalizeRequiredString(args.keyTakeaway, "keyTakeaway"),
+    talkingPoints: normalizeStringList(args.talkingPoints, "talkingPoints"),
     platforms: normalizePlatforms(args.platforms),
-    status: "draft",
-    tags: args.tags.map((tag) => tag.trim()).filter((tag) => tag.length > 0),
-    trendContext: args.trendContext?.trim() || void 0,
-    createdAt: now,
-    updatedAt: now,
-    publishBy
+    tags: normalizeStringList(args.tags, "tags"),
+    publishBy: normalizePublishBy(args.publishBy),
+    trendContext: normalizeOptionalString(args.trendContext, "trendContext")
+  };
+}
+function parseIdeaFilters(args) {
+  const filters = {};
+  if (hasField(args, "status") && args.status !== void 0) {
+    filters.status = normalizeStatus(args.status);
+  }
+  if (hasField(args, "platform") && args.platform !== void 0) {
+    filters.platform = normalizePlatforms([args.platform].flat())[0];
+  }
+  if (hasField(args, "tag") && args.tag !== void 0) {
+    filters.tag = normalizeRequiredString(args.tag, "tag");
+  }
+  if (hasField(args, "priority") && args.priority !== void 0) {
+    const priority = normalizeRequiredString(args.priority, "priority").toLowerCase();
+    if (!SUPPORTED_PRIORITIES.includes(priority)) {
+      throw new Error(`Unsupported priority: ${priority}`);
+    }
+    filters.priority = priority;
+  }
+  if (hasField(args, "limit") && args.limit !== void 0) {
+    if (typeof args.limit !== "number" || !Number.isInteger(args.limit) || args.limit <= 0) {
+      throw new Error("Invalid limit: expected a positive integer");
+    }
+    filters.limit = args.limit;
+  }
+  return filters;
+}
+function extractIdeaUpdates(source) {
+  const updates = {};
+  if (hasField(source, "topic")) {
+    updates.topic = normalizeRequiredString(source.topic, "updates.topic");
+  }
+  if (hasField(source, "hook")) {
+    const hook = normalizeRequiredString(source.hook, "updates.hook");
+    if (hook.length > 80) {
+      throw new Error(`Idea hook must be 80 characters or fewer: ${hook}`);
+    }
+    updates.hook = hook;
+  }
+  if (hasField(source, "audience")) {
+    updates.audience = normalizeRequiredString(source.audience, "updates.audience");
+  }
+  if (hasField(source, "keyTakeaway")) {
+    updates.keyTakeaway = normalizeRequiredString(source.keyTakeaway, "updates.keyTakeaway");
+  }
+  if (hasField(source, "talkingPoints")) {
+    updates.talkingPoints = normalizeStringList(source.talkingPoints, "updates.talkingPoints");
+  }
+  if (hasField(source, "platforms")) {
+    updates.platforms = normalizePlatforms(source.platforms);
+  }
+  if (hasField(source, "tags")) {
+    updates.tags = normalizeStringList(source.tags, "updates.tags");
+  }
+  if (hasField(source, "publishBy")) {
+    updates.publishBy = normalizePublishBy(source.publishBy, "updates.publishBy");
+  }
+  if (hasField(source, "trendContext")) {
+    updates.trendContext = normalizeOptionalString(source.trendContext, "updates.trendContext");
+  }
+  if (hasField(source, "status")) {
+    updates.status = normalizeStatus(source.status);
+  }
+  return updates;
+}
+function parseUpdateIdeaArgs(args) {
+  if (!isRecord(args.updates)) {
+    throw new Error("Invalid update_idea arguments: updates must be an object");
+  }
+  return {
+    issueNumber: normalizeIssueNumber(args.issueNumber),
+    updates: extractIdeaUpdates(args.updates)
   };
 }
+function parseOrganizeIdeasArgs(args) {
+  const { items } = args;
+  if (!Array.isArray(items)) {
+    throw new Error("Invalid organize_ideas arguments: items must be an array");
+  }
+  return items.map((item, index) => {
+    if (!isRecord(item)) {
+      throw new Error(`Invalid organize_ideas item at index ${index}`);
+    }
+    if (item.updates !== void 0 && !isRecord(item.updates)) {
+      throw new Error(`Invalid organize_ideas item at index ${index}: updates must be an object`);
+    }
+    return {
+      issueNumber: normalizeIssueNumber(item.issueNumber),
+      updates: item.updates ? extractIdeaUpdates(item.updates) : void 0,
+      includeRelated: item.includeRelated === void 0 ? true : Boolean(item.includeRelated)
+    };
+  });
+}
+function summarizeLinkedIssues(ideas) {
+  return ideas.map((idea) => ({
+    issueNumber: idea.issueNumber,
+    issueUrl: idea.issueUrl,
+    topic: idea.topic,
+    tags: idea.tags
+  }));
+}
 var IdeationAgent = class extends BaseAgent {
   brandContext;
   existingIdeas;
-  ideasDir;
+  ideaRepo;
   targetCount;
   generatedIdeas = [];
   finalized = false;
@@ -10971,7 +11897,7 @@ var IdeationAgent = class extends BaseAgent {
     super("IdeationAgent", systemPrompt, getProvider2(), model ?? getModelForAgent("IdeationAgent"));
     this.brandContext = context.brandContext;
     this.existingIdeas = [...context.existingIdeas];
-    this.ideasDir = context.ideasDir;
+    this.ideaRepo = context.ideaRepo;
     this.targetCount = context.targetCount;
   }
   resetForRetry() {
@@ -11022,20 +11948,25 @@ var IdeationAgent = class extends BaseAgent {
       },
       {
         name: "get_past_ideas",
-        description: "Return the current idea bank to help avoid duplicate ideas.",
+        description: "List GitHub-backed ideas with optional status, platform, tag, priority, or limit filters.",
         parameters: {
           type: "object",
-          properties: {}
+          properties: {
+            status: { type: "string", enum: [...SUPPORTED_STATUSES] },
+            platform: { type: "string", enum: [...SUPPORTED_PLATFORMS] },
+            tag: { type: "string" },
+            priority: { type: "string", enum: [...SUPPORTED_PRIORITIES] },
+            limit: { type: "integer", minimum: 1 }
+          }
         },
         handler: async (args) => this.handleToolCall("get_past_ideas", args)
       },
       {
         name: "create_idea",
-        description: "Create a new draft content idea and persist it to the idea bank.",
+        description: `Create a new draft GitHub Issue in ${this.ideaRepo} using the full idea schema.`,
         parameters: {
           type: "object",
           properties: {
-            id: { type: "string", description: "Kebab-case idea identifier" },
             topic: { type: "string", description: "Main topic or title" },
             hook: { type: "string", description: "Attention-grabbing hook (80 chars max)" },
             audience: { type: "string", description: "Target audience" },
@@ -11067,10 +11998,98 @@ var IdeationAgent = class extends BaseAgent {
               description: "Why this idea is timely right now"
             }
           },
-          required: ["id", "topic", "hook", "audience", "keyTakeaway", "talkingPoints", "platforms", "tags", "publishBy"]
+          required: ["topic", "hook", "audience", "keyTakeaway", "talkingPoints", "platforms", "tags", "publishBy"]
         },
         handler: async (args) => this.handleToolCall("create_idea", args)
       },
+      {
+        name: "search_ideas",
+        description: "Search GitHub-backed ideas with full-text search across issue content.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Full-text search query" }
+          },
+          required: ["query"]
+        },
+        handler: async (args) => this.handleToolCall("search_ideas", args)
+      },
+      {
+        name: "find_related_ideas",
+        description: "Find related ideas for an issue by looking up the issue and matching similar tagged GitHub ideas.",
+        parameters: {
+          type: "object",
+          properties: {
+            issueNumber: { type: "integer", description: "GitHub issue number for the idea" }
+          },
+          required: ["issueNumber"]
+        },
+        handler: async (args) => this.handleToolCall("find_related_ideas", args)
+      },
+      {
+        name: "update_idea",
+        description: "Update an existing GitHub idea issue: refine copy, adjust labels, or change lifecycle status.",
+        parameters: {
+          type: "object",
+          properties: {
+            issueNumber: { type: "integer", description: "GitHub issue number for the idea" },
+            updates: {
+              type: "object",
+              properties: {
+                topic: { type: "string" },
+                hook: { type: "string" },
+                audience: { type: "string" },
+                keyTakeaway: { type: "string" },
+                talkingPoints: { type: "array", items: { type: "string" } },
+                platforms: { type: "array", items: { type: "string", enum: [...SUPPORTED_PLATFORMS] } },
+                tags: { type: "array", items: { type: "string" } },
+                publishBy: { type: "string" },
+                trendContext: { type: "string" },
+                status: { type: "string", enum: [...SUPPORTED_STATUSES] }
+              }
+            }
+          },
+          required: ["issueNumber", "updates"]
+        },
+        handler: async (args) => this.handleToolCall("update_idea", args)
+      },
+      {
+        name: "organize_ideas",
+        description: "Batch update GitHub idea issue labels/statuses and return related issue links for clustering.",
+        parameters: {
+          type: "object",
+          properties: {
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  issueNumber: { type: "integer" },
+                  updates: {
+                    type: "object",
+                    properties: {
+                      topic: { type: "string" },
+                      hook: { type: "string" },
+                      audience: { type: "string" },
+                      keyTakeaway: { type: "string" },
+                      talkingPoints: { type: "array", items: { type: "string" } },
+                      platforms: { type: "array", items: { type: "string", enum: [...SUPPORTED_PLATFORMS] } },
+                      tags: { type: "array", items: { type: "string" } },
+                      publishBy: { type: "string" },
+                      trendContext: { type: "string" },
+                      status: { type: "string", enum: [...SUPPORTED_STATUSES] }
+                    }
+                  },
+                  includeRelated: { type: "boolean" }
+                },
+                required: ["issueNumber"]
+              }
+            }
+          },
+          required: ["items"]
+        },
+        handler: async (args) => this.handleToolCall("organize_ideas", args)
+      },
       {
         name: "finalize_ideas",
         description: "Signal that idea generation is complete.",
@@ -11086,16 +12105,18 @@ var IdeationAgent = class extends BaseAgent {
     switch (toolName) {
       case "get_brand_context":
         return this.brandContext ?? await Promise.resolve(getBrandConfig());
-      case "get_past_ideas": {
-        const ideas = await readIdeaBank(this.ideasDir);
-        return ideas.map((idea) => ({
-          id: idea.id,
-          topic: idea.topic,
-          status: idea.status
-        }));
-      }
+      case "get_past_ideas":
+        return await listIdeas(parseIdeaFilters(args));
       case "create_idea":
-        return this.handleCreateIdea(args);
+        return await this.handleCreateIdea(args);
+      case "search_ideas":
+        return await searchIdeas(normalizeRequiredString(args.query, "query"));
+      case "find_related_ideas":
+        return await this.handleFindRelatedIdeas(args);
+      case "update_idea":
+        return await this.handleUpdateIdea(args);
+      case "organize_ideas":
+        return await this.handleOrganizeIdeas(args);
       case "finalize_ideas":
         this.finalized = true;
         return { success: true, count: this.generatedIdeas.length };
@@ -11107,43 +12128,70 @@ var IdeationAgent = class extends BaseAgent {
     if (this.generatedIdeas.length >= this.targetCount) {
       throw new Error(`Target idea count already reached (${this.targetCount})`);
     }
-    const createArgs = this.parseCreateIdeaArgs(args);
-    const idea = buildIdea(createArgs);
-    const duplicateTopic = this.findDuplicateTopic(idea.topic);
+    const input = parseCreateIdeaInput(args);
+    const duplicateTopic = this.findDuplicateTopic(input.topic);
     if (duplicateTopic) {
       throw new Error(`Duplicate idea topic detected: ${duplicateTopic}`);
     }
-    const duplicateId = this.findDuplicateId(idea.id);
-    if (duplicateId) {
-      throw new Error(`Duplicate idea ID detected: ${duplicateId}`);
-    }
-    await writeIdea(idea, this.ideasDir);
-    this.generatedIdeas.push(idea);
-    logger_default.info(`[IdeationAgent] Created idea ${idea.id}: ${idea.topic}`);
+    const idea = await createIdea(input);
+    this.upsertIdea(this.existingIdeas, idea);
+    this.upsertIdea(this.generatedIdeas, idea);
+    logger_default.info(`[IdeationAgent] Created GitHub idea #${idea.issueNumber}: ${idea.topic}`);
     return { success: true, idea };
   }
-  parseCreateIdeaArgs(args) {
-    const { id, topic, hook, audience, keyTakeaway, talkingPoints, platforms, tags, publishBy, trendContext } = args;
-    if (typeof id !== "string" || typeof topic !== "string" || typeof hook !== "string" || typeof audience !== "string" || typeof keyTakeaway !== "string" || !isStringArray2(talkingPoints) || !isStringArray2(platforms) || !isStringArray2(tags) || typeof publishBy !== "string" || trendContext !== void 0 && typeof trendContext !== "string") {
-      throw new Error("Invalid create_idea arguments");
+  async handleFindRelatedIdeas(args) {
+    const issueNumber = normalizeIssueNumber(args.issueNumber);
+    const idea = await getIdea(issueNumber);
+    if (!idea) {
+      throw new Error(`Idea #${issueNumber} was not found in ${this.ideaRepo}`);
     }
+    return await findRelatedIdeas(idea);
+  }
+  async handleUpdateIdea(args) {
+    const { issueNumber, updates } = parseUpdateIdeaArgs(args);
+    const idea = await updateIdea(issueNumber, updates);
+    this.upsertIdea(this.existingIdeas, idea);
+    this.syncGeneratedIdea(idea);
+    logger_default.info(`[IdeationAgent] Updated GitHub idea #${idea.issueNumber}: ${idea.topic}`);
+    return { success: true, idea };
+  }
+  async handleOrganizeIdeas(args) {
+    const items = parseOrganizeIdeasArgs(args);
+    const organizedItems = await Promise.all(
+      items.map(async (item) => {
+        const currentIdea = await getIdea(item.issueNumber);
+        if (!currentIdea) {
+          throw new Error(`Idea #${item.issueNumber} was not found in ${this.ideaRepo}`);
+        }
+        const nextIdea = item.updates ? await updateIdea(item.issueNumber, item.updates) : currentIdea;
+        this.upsertIdea(this.existingIdeas, nextIdea);
+        this.syncGeneratedIdea(nextIdea);
+        const relatedIdeas = item.includeRelated ? await findRelatedIdeas(nextIdea) : [];
+        return {
+          issueNumber: nextIdea.issueNumber,
+          idea: nextIdea,
+          linkedIssues: summarizeLinkedIssues(relatedIdeas)
+        };
+      })
+    );
     return {
-      id,
-      topic,
-      hook,
-      audience,
-      keyTakeaway,
-      talkingPoints,
-      platforms,
-      tags,
-      publishBy,
-      trendContext
+      success: true,
+      items: organizedItems
     };
   }
-  findDuplicateId(id) {
-    const normalizedId = id.trim().toLowerCase();
-    const existing = [...this.existingIdeas, ...this.generatedIdeas].find((idea) => idea.id.trim().toLowerCase() === normalizedId);
-    return existing?.id;
+  upsertIdea(collection, nextIdea) {
+    const existingIndex = collection.findIndex((idea) => idea.issueNumber === nextIdea.issueNumber);
+    if (existingIndex === -1) {
+      collection.push(nextIdea);
+      return;
+    }
+    collection.splice(existingIndex, 1, nextIdea);
+  }
+  syncGeneratedIdea(nextIdea) {
+    const existingIndex = this.generatedIdeas.findIndex((idea) => idea.issueNumber === nextIdea.issueNumber);
+    if (existingIndex !== -1) {
+      this.generatedIdeas.splice(existingIndex, 1, nextIdea);
+    }
   }
   findDuplicateTopic(topic) {
     const normalizedTopic = topic.trim().toLowerCase();
@@ -11166,12 +12214,12 @@ async function generateIdeas(options = {}) {
     config2.BRAND_PATH = options.brandPath;
   }
   const brandContext = await loadBrandContext(options.brandPath);
-  const existingIdeas = await readIdeaBank(options.ideasDir);
-  const systemPrompt = buildSystemPrompt3(brandContext, existingIdeas, seedTopics, count);
+  const existingIdeas = await listIdeas({ limit: DEFAULT_EXISTING_IDEA_LIMIT });
+  const systemPrompt = buildSystemPrompt3(brandContext, existingIdeas, seedTopics, count, config2.IDEAS_REPO);
   const agent = new IdeationAgent(systemPrompt, {
     brandContext,
     existingIdeas,
-    ideasDir: options.ideasDir,
+    ideaRepo: config2.IDEAS_REPO,
     targetCount: count
   });
   try {
@@ -11217,6 +12265,7 @@ function createScheduleAgent(...args) {
 }
 
 // src/L6-pipeline/pipeline.ts
+init_types();
 async function runStage(stageName, fn, stageResults) {
   const start = Date.now();
   try {
@@ -12104,7 +13153,7 @@ Type \x1B[33mexit\x1B[0m or \x1B[33mquit\x1B[0m to leave. Press Ctrl+C to stop.
 
 // src/L7-app/commands/ideate.ts
 init_environment();
-init_ideaStore();
+init_ideaService();
 
 // src/L6-pipeline/ideation.ts
 function generateIdeas3(...args) {
@@ -12115,8 +13164,8 @@ function generateIdeas3(...args) {
 async function runIdeate(options = {}) {
   initConfig();
   if (options.list) {
-    const ideas2 = await readIdeaBank(options.output);
-    const filtered = options.status ? ideas2.filter((i) => i.status === options.status) : ideas2;
+    const ideas2 = await listIdeas();
+    const filtered = options.status ? ideas2.filter((idea) => idea.status === options.status) : ideas2;
     if (filtered.length === 0) {
       console.log("No ideas found.");
       if (options.status) {
@@ -12166,9 +13215,9 @@ ${filtered.length} idea(s) total`);
     console.log(`     Status: ${idea.status}`);
     console.log("");
   }
-  console.log("Ideas saved to ./ideas/ directory.");
+  console.log("Ideas saved to the GitHub-backed idea service.");
   console.log("Use `vidpipe ideate --list` to view all ideas.");
-  console.log("Use `vidpipe process video.mp4 --ideas <id1>,<id2>` to link ideas to a recording.");
+  console.log("Use `vidpipe process video.mp4 --ideas <issueNumber1>,<issueNumber2>` to link ideas to a recording.");
 }
 
 // src/L1-infra/http/http.ts
@@ -12179,14 +13228,16 @@ import { Router } from "express";
 init_paths();
 
 // src/L7-app/review/routes.ts
-init_ideaService();
+init_ideaService2();
+init_types();
 init_configLogger();
 
 // src/L7-app/review/approvalQueue.ts
 init_fileSystem();
-init_ideaService();
+init_ideaService2();
 
 // src/L3-services/socialPosting/accountMapping.ts
+init_types();
 init_configLogger();
 init_fileSystem();
 init_paths();
@@ -12290,6 +13341,7 @@ async function getAccountId(platform) {
 }
 
 // src/L7-app/review/approvalQueue.ts
+init_types();
 init_configLogger();
 var queue = [];
 var processing = false;
@@ -12329,20 +13381,32 @@ async function processApprovalBatch(itemIds) {
     itemIds.map(async (id) => ({ id, item: await getItem(id) }))
   );
   const itemMap = new Map(loadedItems.map(({ id, item }) => [id, item]));
-  const enriched = await Promise.all(
-    loadedItems.map(async ({ id, item }) => {
-      if (!item?.metadata.ideaIds?.length) {
-        return { id, publishBy: null, hasIdeas: false };
+  const allIdeaIds = /* @__PURE__ */ new Set();
+  for (const { item } of loadedItems) {
+    if (item?.metadata.ideaIds?.length) {
+      for (const ideaId of item.metadata.ideaIds) {
+        allIdeaIds.add(ideaId);
       }
-      try {
-        const ideas = await getIdeasByIds(item.metadata.ideaIds);
-        const dates = ideas.map((idea) => idea.publishBy).filter((publishBy) => Boolean(publishBy)).sort();
-        return { id, publishBy: dates[0] ?? null, hasIdeas: true };
-      } catch {
-        return { id, publishBy: null, hasIdeas: true };
+    }
+  }
+  let ideaMap = /* @__PURE__ */ new Map();
+  if (allIdeaIds.size > 0) {
+    try {
+      const allIdeas = await getIdeasByIds([...allIdeaIds]);
+      for (const idea of allIdeas) {
+        ideaMap.set(idea.id, idea);
+        ideaMap.set(String(idea.issueNumber), idea);
       }
-    })
-  );
+    } catch {
+    }
+  }
+  const enriched = loadedItems.map(({ id, item }) => {
+    if (!item?.metadata.ideaIds?.length) {
+      return { id, publishBy: null, hasIdeas: false };
+    }
+    const dates = item.metadata.ideaIds.map((ideaId) => ideaMap.get(ideaId)?.publishBy).filter((publishBy) => Boolean(publishBy)).sort();
+    return { id, publishBy: dates[0] ?? null, hasIdeas: true };
+  });
   const now = Date.now();
   const sevenDays = 7 * 24 * 60 * 60 * 1e3;
   enriched.sort((a, b) => {
@@ -12480,7 +13544,31 @@ async function enrichQueueItem(item) {
   };
 }
 async function enrichQueueItems(items) {
-  return Promise.all(items.map((item) => enrichQueueItem(item)));
+  const allIdeaIds = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (item.metadata.ideaIds?.length) {
+      for (const ideaId of item.metadata.ideaIds) {
+        allIdeaIds.add(ideaId);
+      }
+    }
+  }
+  let publishByMap = /* @__PURE__ */ new Map();
+  if (allIdeaIds.size > 0) {
+    try {
+      const ideas = await getIdeasByIds([...allIdeaIds]);
+      for (const idea of ideas) {
+        publishByMap.set(idea.id, idea.publishBy);
+        publishByMap.set(String(idea.issueNumber), idea.publishBy);
+      }
+    } catch {
+    }
+  }
+  return items.map((item) => {
+    if (!item.metadata.ideaIds?.length) return { ...item };
+    const dates = item.metadata.ideaIds.map((id) => publishByMap.get(id)).filter((publishBy) => Boolean(publishBy)).sort();
+    const ideaPublishBy = dates[0];
+    return ideaPublishBy ? { ...item, ideaPublishBy } : { ...item };
+  });
 }
 async function enrichGroupedQueueItems(groups) {
   return Promise.all(groups.map(async (group) => ({
@@ -12806,7 +13894,7 @@ var defaultCmd = program.command("process", { isDefault: true }).argument("[vide
   logger_default.info(`Output dir:   ${config2.OUTPUT_DIR}`);
   let ideas;
   if (opts.ideas) {
-    const { getIdeasByIds: getIdeasByIds2 } = await Promise.resolve().then(() => (init_ideaService(), ideaService_exports));
+    const { getIdeasByIds: getIdeasByIds2 } = await Promise.resolve().then(() => (init_ideaService2(), ideaService_exports2));
     const ideaIds = opts.ideas.split(",").map((id) => id.trim()).filter(Boolean);
     try {
       ideas = await getIdeasByIds2(ideaIds);
@@ -12823,10 +13911,10 @@ var defaultCmd = program.command("process", { isDefault: true }).argument("[vide
     await processVideoSafe(resolvedPath, ideas);
     if (ideas && ideas.length > 0) {
       try {
-        const { markRecorded: markRecorded2 } = await Promise.resolve().then(() => (init_ideaService(), ideaService_exports));
+        const { markRecorded: markRecorded3 } = await Promise.resolve().then(() => (init_ideaService(), ideaService_exports));
         const slug = resolvedPath.replace(/\\/g, "/").split("/").pop()?.replace(/\.(mp4|mov|webm|avi|mkv)$/i, "") || "";
         for (const idea of ideas) {
-          await markRecorded2(idea.id, slug);
+          await markRecorded3(idea.issueNumber, slug);
         }
         logger_default.info(`Marked ${ideas.length} idea(s) as recorded`);
       } catch (err) {