@openpome/local-gateway 0.38.0-alpha.0 → 0.41.0-alpha.0

package/dist/index.js

@@ -16,6 +16,7 @@ import { createDefaultWorkItemSourceRegistry, createJiraCloudOAuthLogin, exchang
 const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 const jiraOAuthCredentialAccount = "jira-cloud/oauth";
+const jiraApiTokenCredentialAccount = "jira-cloud/api-token";
 const githubOAuthCredentialAccount = "github/oauth";
 const openAiCredentialAccount = "model/openai/api-key";
 const anthropicCredentialAccount = "model/anthropic/api-key";
@@ -41,7 +42,7 @@ const maxWorkspaceScanRepositories = 200;
 export function getGatewayHealth() {
     return {
         status: "ok",
-        version: "0.38.0-alpha.0"
+        version: "0.41.0-alpha.0"
     };
 }
 export async function initOpenPome() {
@@ -453,11 +454,17 @@ export async function startTaskSession(key, env = process.env) {
         updatedAt: now
     };
     const events = createSessionStartEvents(session, resolution.workItem, workspaceCandidate, now);
+    const repositoryKnowledge = workspaceCandidate?.workspace.path
+        ? await buildRepositoryKnowledge(workspaceCandidate.workspace, now)
+        : undefined;
+    const intelligence = buildWorkItemIntelligenceReport(resolution.workItem, workspaceCandidate, repositoryKnowledge);
     await writeActiveTaskSession(paths.homeDirectory, {
         version: 1,
         session,
         workItem: resolution.workItem,
         workspaceCandidate,
+        intelligence,
+        repositoryKnowledge,
         events,
         approvalHistory: []
     });
@@ -465,6 +472,8 @@ export async function startTaskSession(key, env = process.env) {
         session,
         workItem: resolution.workItem,
         workspaceCandidate,
+        intelligence,
+        repositoryKnowledge,
         sessionFile: getActiveTaskSessionFile(paths.homeDirectory)
     };
 }
@@ -483,6 +492,8 @@ export async function getTaskSessionStatus() {
         session: persisted.session,
         workItem: persisted.workItem,
         workspaceCandidate: persisted.workspaceCandidate,
+        intelligence: persisted.intelligence,
+        repositoryKnowledge: persisted.repositoryKnowledge,
         plan: persisted.plan,
         planApproval: persisted.planApproval,
         events: persisted.events ?? [],
@@ -501,12 +512,12 @@ export async function getTaskSessionStatus() {
 }
 export async function getAssistantDecision() {
     const status = await getTaskSessionStatus();
+    const jira = await getJiraAuthStatus();
     if (!status.active || !status.session || !status.workItem) {
-        const jira = await getJiraAuthStatus();
         if (!jira.configured) {
             return buildAssistantDecision(status, "connect_jira", "Connect Jira", "OpenPome needs Jira access before it can show assigned stories.", [
                 "pome onboard",
-                "pome auth jira login --listen",
+                "pome auth jira token",
                 "pome demo"
             ], [jira.detail]);
         }
@@ -515,6 +526,16 @@ export async function getAssistantDecision() {
             "pome start <KEY>"
         ]);
     }
+    if (!jira.configured && process.env["OPENPOME_DEMO"] !== "1") {
+        return buildAssistantDecision(status, "connect_jira", "Connect Jira", "OpenPome needs Jira connected before continuing this story as real work.", [
+            "pome auth jira token",
+            "pome reset",
+            "pome demo"
+        ], [
+            jira.detail,
+            "If this is an old demo/session, run `pome reset` and start from `pome work` after connecting Jira."
+        ]);
+    }
     if (!status.plan) {
         return buildAssistantDecision(status, "create_plan", "Create implementation plan", "Build a repo-aware implementation plan from the latest Jira story.", [
             "pome plan"
@@ -1653,6 +1674,49 @@ export async function getJiraAuthStatus(env = process.env) {
         ...status
     };
 }
+export async function configureJiraApiTokenAuth(input, env = process.env) {
+    const baseUrl = normalizeJiraBaseUrl(input.baseUrl);
+    const email = input.email.trim();
+    const apiToken = input.apiToken.trim();
+    if (!baseUrl) {
+        throw new Error("Jira site URL is required. Example: https://your-company.atlassian.net");
+    }
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/u.test(email)) {
+        throw new Error("Jira email is required. Use the email address you use to sign in to Atlassian.");
+    }
+    if (!apiToken) {
+        throw new Error("Jira API token is required.");
+    }
+    const store = createCredentialStore();
+    if (!store.isAvailable()) {
+        throw new Error(`Credential store is unavailable: ${store.backend}. Use OPENPOME_JIRA_BASE_URL, OPENPOME_JIRA_EMAIL, and OPENPOME_JIRA_API_TOKEN environment variables instead.`);
+    }
+    const credential = {
+        baseUrl,
+        email,
+        apiToken,
+        storedAt: new Date().toISOString()
+    };
+    await setJsonCredential(store, jiraApiTokenCredentialAccount, credential);
+    const source = await createJiraSource({
+        ...env,
+        OPENPOME_JIRA_BASE_URL: baseUrl,
+        OPENPOME_JIRA_EMAIL: email,
+        OPENPOME_JIRA_API_TOKEN: apiToken
+    });
+    const reachability = await source.checkReachability();
+    if (reachability.status !== "ok" && reachability.status !== "reachable") {
+        throw new Error(`Jira credentials were saved, but Jira was not reachable yet. ${reachability.detail}`);
+    }
+    return {
+        provider: "jira-cloud",
+        stored: true,
+        mode: "api-token",
+        baseUrl,
+        email,
+        detail: "Jira connected. OpenPome can now load your assigned stories."
+    };
+}
 export function createJiraOAuthLogin(env = process.env) {
     const clientId = env["OPENPOME_JIRA_OAUTH_CLIENT_ID"];
     const redirectUri = env["OPENPOME_JIRA_OAUTH_REDIRECT_URI"] ?? "http://127.0.0.1:48731/auth/jira/callback";
@@ -1764,10 +1828,15 @@ async function createJiraSource(env) {
     const paths = getOpenPomePaths();
     const localConfig = await readConfigIfPresent(paths.configFile);
     const selectedBoardScope = getActiveJiraBoardScope(localConfig);
+    const storedApiToken = await readStoredJiraApiToken();
     const storedOAuth = await refreshStoredJiraOAuthIfNeeded(await readStoredJiraOAuth(), env);
+    const connectorCredentials = {
+        ...(storedApiToken ? { [jiraApiTokenCredentialAccount]: storedApiToken } : {}),
+        ...(storedOAuth ? { [jiraOAuthCredentialAccount]: storedOAuth } : {})
+    };
     return workItemSourceRegistry.getActiveSource(env, {
         activeScope: selectedBoardScope,
-        connectorCredentials: storedOAuth ? { [jiraOAuthCredentialAccount]: storedOAuth } : undefined
+        connectorCredentials: Object.keys(connectorCredentials).length ? connectorCredentials : undefined
     });
 }
 function normalizeModelProviderId(provider) {
@@ -1867,6 +1936,13 @@ async function readStoredJiraOAuth() {
     }
     return getJsonCredential(store, jiraOAuthCredentialAccount);
 }
+async function readStoredJiraApiToken() {
+    const store = createCredentialStore();
+    if (!store.isAvailable()) {
+        return undefined;
+    }
+    return getJsonCredential(store, jiraApiTokenCredentialAccount);
+}
 async function readStoredGitHubOAuth() {
     const store = createCredentialStore();
     if (!store.isAvailable()) {
@@ -2064,6 +2140,13 @@ function getOpenPomePaths() {
         configFile: join(homeDirectory, "config.json")
     };
 }
+function normalizeJiraBaseUrl(value) {
+    const trimmed = value.trim().replace(/\/+$/u, "");
+    if (!trimmed) {
+        return "";
+    }
+    return /^https?:\/\//iu.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
 async function readConfigIfPresent(configFile) {
     try {
         const content = await readFile(configFile, "utf8");
@@ -2285,6 +2368,255 @@ async function readPackageScripts(packageFile) {
         throw error;
     }
 }
+async function buildRepositoryKnowledge(workspace, now) {
+    if (!workspace.path) {
+        return undefined;
+    }
+    const workspacePath = workspace.path;
+    const trackedFiles = await listWorkspaceFilesForKnowledge(workspacePath);
+    const packageManager = detectPackageManager(workspacePath);
+    const manifests = trackedFiles
+        .filter((filePath) => basename(filePath) === "package.json")
+        .filter((filePath) => !isGeneratedWorkspacePath(filePath) && !isSensitiveWorkspacePath(filePath))
+        .sort((left, right) => left.localeCompare(right))
+        .slice(0, 80);
+    const rootScripts = await readPackageScripts(join(workspacePath, "package.json"));
+    const packageNames = await readPackageNamesFromManifests(workspacePath, manifests);
+    const codeowners = await readRepositoryCodeowners(workspacePath);
+    const knowledgeFile = getRepositoryKnowledgeFile(workspacePath);
+    const pathMap = buildRepositoryPathMap(trackedFiles);
+    const knowledge = {
+        schemaVersion: 1,
+        createdAt: await readExistingRepositoryKnowledgeCreatedAt(knowledgeFile, now),
+        updatedAt: now,
+        workspace: {
+            name: workspace.name,
+            path: workspacePath,
+            remoteUrls: workspace.remoteUrls,
+            currentBranch: workspace.currentBranch
+        },
+        packageMap: {
+            packageManager,
+            packageNames: packageNames.length ? packageNames : workspace.packageNames ?? [],
+            manifests,
+            scripts: await buildRepositoryScriptMap(workspacePath, manifests, rootScripts),
+            buildCommands: buildRepositoryCommands(packageManager, rootScripts, ["build", "compile"]),
+            testCommands: buildRepositoryCommands(packageManager, rootScripts, ["test", "test:unit", "test:integration", "test:e2e"]),
+            lintCommands: buildRepositoryCommands(packageManager, rootScripts, ["lint", "lint:fix"]),
+            typecheckCommands: buildRepositoryCommands(packageManager, rootScripts, ["typecheck", "tsc"]),
+            validateCommands: buildRepositoryCommands(packageManager, rootScripts, ["validate", "check", "ci"])
+        },
+        pathMap,
+        moduleBoundaries: buildRepositoryModuleBoundaries(trackedFiles, packageNames),
+        ownership: {
+            codeownersFiles: codeowners.codeownersFiles,
+            owners: codeowners.owners,
+            signals: codeowners.signals
+        },
+        knowledgeFile
+    };
+    await mkdir(dirname(knowledgeFile), { recursive: true });
+    await writeFile(knowledgeFile, `${JSON.stringify(knowledge, null, 2)}\n`, "utf8");
+    return knowledge;
+}
+async function readExistingRepositoryKnowledgeCreatedAt(knowledgeFile, fallback) {
+    try {
+        const content = await readFile(knowledgeFile, "utf8");
+        const parsed = JSON.parse(content);
+        return typeof parsed.createdAt === "string" ? parsed.createdAt : fallback;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return fallback;
+        }
+        if (error instanceof SyntaxError) {
+            return fallback;
+        }
+        throw error;
+    }
+}
+function getRepositoryKnowledgeFile(workspacePath) {
+    return join(workspacePath, ".pome", "knowledge", "repository.json");
+}
+async function readPackageNamesFromManifests(workspacePath, manifests) {
+    const names = [];
+    for (const manifest of manifests.slice(0, 80)) {
+        const name = await readPackageName(join(workspacePath, manifest));
+        if (name) {
+            names.push(name);
+        }
+    }
+    return uniqueStrings(names).slice(0, 80);
+}
+async function buildRepositoryScriptMap(workspacePath, manifests, rootScripts) {
+    const scripts = { ...rootScripts };
+    for (const manifest of manifests.filter((filePath) => filePath !== "package.json").slice(0, 40)) {
+        const packageName = await readPackageName(join(workspacePath, manifest));
+        const packageScripts = await readPackageScripts(join(workspacePath, manifest));
+        const prefix = packageName ?? dirname(manifest);
+        for (const [scriptName, script] of Object.entries(packageScripts)) {
+            scripts[`${prefix}:${scriptName}`] = script;
+        }
+    }
+    return Object.fromEntries(Object.entries(scripts).slice(0, 120));
+}
+function buildRepositoryCommands(packageManager, scripts, preferredScriptNames) {
+    return preferredScriptNames
+        .filter((scriptName) => Boolean(scripts[scriptName]))
+        .map((scriptName) => buildPackageScriptCommand(packageManager, scriptName))
+        .slice(0, 8);
+}
+function buildRepositoryPathMap(files) {
+    const source = [];
+    const tests = [];
+    const config = [];
+    const generated = [];
+    const sensitive = [];
+    const docs = [];
+    for (const filePath of files.slice(0, 2000)) {
+        const normalized = filePath.replace(/\\/gu, "/");
+        if (isSensitiveWorkspacePath(normalized)) {
+            sensitive.push(normalized);
+            continue;
+        }
+        if (isGeneratedWorkspacePath(normalized)) {
+            generated.push(normalized);
+            continue;
+        }
+        if (isDocumentationWorkspacePath(normalized)) {
+            docs.push(normalized);
+        }
+        if (isConfigWorkspacePath(normalized)) {
+            config.push(normalized);
+            continue;
+        }
+        if (isTestLikeFile(normalized)) {
+            tests.push(normalized);
+            continue;
+        }
+        if (isSourceWorkspacePath(normalized)) {
+            source.push(normalized);
+        }
+    }
+    return {
+        source: uniqueStrings(source).slice(0, 160),
+        tests: uniqueStrings(tests).slice(0, 120),
+        config: uniqueStrings(config).slice(0, 80),
+        generated: uniqueStrings(generated).slice(0, 80),
+        sensitive: uniqueStrings(sensitive).slice(0, 40),
+        docs: uniqueStrings(docs).slice(0, 40)
+    };
+}
+function buildRepositoryModuleBoundaries(files, packageNames) {
+    const boundaries = new Map();
+    for (const filePath of files) {
+        if (basename(filePath) === "package.json") {
+            const directory = dirname(filePath);
+            const normalizedDirectory = directory === "." ? "." : directory;
+            const packageName = packageNames.find((name) => normalizeModuleName(name).includes(basename(normalizedDirectory).toLowerCase()));
+            boundaries.set(normalizedDirectory, {
+                name: packageName ?? (basename(normalizedDirectory) || "root"),
+                path: normalizedDirectory,
+                kind: inferModuleBoundaryKind(normalizedDirectory),
+                reason: "Package manifest defines a build or runtime boundary."
+            });
+            continue;
+        }
+        const topLevel = filePath.split("/")[0] ?? "";
+        if (!topLevel || topLevel.startsWith(".")) {
+            continue;
+        }
+        if (/^(apps|services|packages|connectors|src|lib)$/u.test(topLevel)) {
+            const parts = filePath.split("/");
+            const boundaryPath = topLevel === "src" || topLevel === "lib" ? topLevel : parts.slice(0, 2).join("/");
+            if (boundaryPath && !boundaries.has(boundaryPath)) {
+                boundaries.set(boundaryPath, {
+                    name: basename(boundaryPath),
+                    path: boundaryPath,
+                    kind: inferModuleBoundaryKind(boundaryPath),
+                    reason: `Repository path suggests a ${inferModuleBoundaryKind(boundaryPath)} boundary.`
+                });
+            }
+        }
+    }
+    return [...boundaries.values()]
+        .sort((left, right) => left.path.localeCompare(right.path))
+        .slice(0, 80);
+}
+function inferModuleBoundaryKind(path) {
+    if (path.startsWith("apps/")) {
+        return "application";
+    }
+    if (path.startsWith("services/")) {
+        return "service";
+    }
+    if (path.startsWith("packages/")) {
+        return "package";
+    }
+    if (path.startsWith("connectors/")) {
+        return "connector";
+    }
+    if (path === "src" || path.startsWith("src/") || path === "lib" || path.startsWith("lib/")) {
+        return "source";
+    }
+    return "module";
+}
+function normalizeModuleName(value) {
+    return value.toLowerCase().replace(/^@[^/]+\//u, "").replace(/[^a-z0-9]+/gu, "-");
+}
+async function readRepositoryCodeowners(workspacePath) {
+    const codeownersFiles = [".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"];
+    const foundFiles = [];
+    const owners = [];
+    const signals = [];
+    for (const filePath of codeownersFiles) {
+        const content = await readOptionalTextFile(join(workspacePath, filePath), 32_000);
+        if (!content) {
+            continue;
+        }
+        foundFiles.push(filePath);
+        for (const line of content.split(/\r?\n/u)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) {
+                continue;
+            }
+            const parts = trimmed.split(/\s+/u);
+            const pathPattern = parts[0];
+            const lineOwners = parts.slice(1).filter((owner) => owner.startsWith("@") || owner.includes("@"));
+            owners.push(...lineOwners);
+            if (pathPattern && lineOwners.length) {
+                signals.push(`${pathPattern}: ${lineOwners.slice(0, 4).join(", ")}`);
+            }
+        }
+    }
+    return {
+        codeownersFiles: foundFiles,
+        owners: uniqueStrings(owners).slice(0, 40),
+        signals: uniqueStrings(signals).slice(0, 40)
+    };
+}
+function isSourceWorkspacePath(filePath) {
+    const lower = filePath.toLowerCase();
+    return /\.(ts|tsx|js|jsx|mjs|cjs|py|java|kt|go|rs|rb|php|cs|swift|scala|sh|sql)$/u.test(lower)
+        && !isConfigWorkspacePath(lower)
+        && !isGeneratedWorkspacePath(lower);
+}
+function isConfigWorkspacePath(filePath) {
+    const lower = filePath.toLowerCase();
+    return /(^|\/)(package\.json|pnpm-workspace\.yaml|tsconfig[^/]*\.json|vite\.config\.[cm]?[jt]s|vitest\.config\.[cm]?[jt]s|jest\.config\.[cm]?[jt]s|eslint\.config\.[cm]?[jt]s|\.eslintrc[^/]*|\.prettierrc[^/]*|dockerfile|docker-compose\.ya?ml|makefile|cargo\.toml|go\.mod|pom\.xml|gradle\.properties|build\.gradle|pyproject\.toml|requirements\.txt|ruff\.toml)$/u.test(lower)
+        || /(^|\/)(\.github\/workflows\/.+\.ya?ml|config\/.+\.(json|ya?ml|toml|ini))$/u.test(lower);
+}
+function isGeneratedWorkspacePath(filePath) {
+    const lower = filePath.toLowerCase();
+    return /(^|\/)(dist|build|coverage|out|target|\.next|\.nuxt|\.turbo|\.cache|vendor|node_modules|generated|__generated__)\//u.test(lower)
+        || /\.(tsbuildinfo|min\.js|min\.css|map)$/u.test(lower)
+        || /(^|\/)(pnpm-lock\.yaml|package-lock\.json|yarn\.lock|bun\.lockb?)$/u.test(lower);
+}
+function isDocumentationWorkspacePath(filePath) {
+    const lower = filePath.toLowerCase();
+    return /(^|\/)(readme|changelog|license|contributing)(\.[a-z0-9]+)?$/u.test(lower)
+        || lower.startsWith("docs/");
+}
 async function readWorkspaceReadmeKeywords(directory) {
     const readmeFiles = ["README.md", "README.txt", "readme.md"];
     const keywords = [];
@@ -2737,6 +3069,7 @@ function selectArchivedTaskSession(sessions, sessionId) {
 }
 function buildPlanningContext(session) {
     const workspace = session.workspaceCandidate?.workspace;
+    const knowledge = session.repositoryKnowledge;
     const missingRequirementSignals = detectMissingRequirementSignals(session.workItem);
     const context = [
         `Work item type: ${session.workItem.type}`,
@@ -2759,7 +3092,17 @@ function buildPlanningContext(session) {
         workspace?.readmeKeywords?.length ? `README signals: ${workspace.readmeKeywords.slice(0, 12).join(", ")}` : undefined,
         workspace?.codeownersKeywords?.length ? `Ownership signals: ${workspace.codeownersKeywords.slice(0, 12).join(", ")}` : undefined,
         workspace?.recentBranches?.length ? `Recent branches: ${workspace.recentBranches.slice(0, 8).join(", ")}` : undefined,
-        workspace?.recentCommitRefs?.length ? `Recent work refs: ${workspace.recentCommitRefs.slice(0, 12).join(", ")}` : undefined
+        workspace?.recentCommitRefs?.length ? `Recent work refs: ${workspace.recentCommitRefs.slice(0, 12).join(", ")}` : undefined,
+        knowledge ? `Repository knowledge file: ${knowledge.knowledgeFile}` : undefined,
+        knowledge ? `Repository package manager: ${knowledge.packageMap.packageManager}` : undefined,
+        knowledge?.packageMap.packageNames.length ? `Repository packages: ${knowledge.packageMap.packageNames.slice(0, 12).join(", ")}` : undefined,
+        knowledge?.moduleBoundaries.length
+            ? `Module boundaries: ${knowledge.moduleBoundaries.slice(0, 12).map((boundary) => `${boundary.kind}:${boundary.path}`).join(", ")}`
+            : undefined,
+        knowledge ? `Path map: ${knowledge.pathMap.source.length} source, ${knowledge.pathMap.tests.length} test, ${knowledge.pathMap.config.length} config, ${knowledge.pathMap.generated.length} generated, ${knowledge.pathMap.sensitive.length} sensitive paths` : undefined,
+        knowledge?.ownership.owners.length ? `Code owners: ${knowledge.ownership.owners.slice(0, 12).join(", ")}` : undefined,
+        knowledge?.packageMap.validateCommands.length ? `Validation commands: ${knowledge.packageMap.validateCommands.join(", ")}` : undefined,
+        knowledge?.packageMap.testCommands.length ? `Test commands: ${knowledge.packageMap.testCommands.join(", ")}` : undefined
     ];
     return context.filter((item) => Boolean(item));
 }
@@ -2813,6 +3156,307 @@ function buildInitialImplementationPlan(workItem, workspaceCandidate) {
         missingInfo
     };
 }
+function buildWorkItemIntelligenceReport(workItem, workspaceCandidate, repositoryKnowledge) {
+    const acceptanceCriteria = extractAcceptanceCriteria(workItem);
+    const missingQuestions = detectMissingRequirementSignals(workItem);
+    const linkedReferences = summarizeLinkedReferences(workItem);
+    const likelyFiles = inferLikelyFileHints(workItem, workspaceCandidate, repositoryKnowledge);
+    const dependencies = inferDependencySignals(workItem, workspaceCandidate, repositoryKnowledge);
+    const risks = inferWorkItemRisks(workItem, workspaceCandidate, acceptanceCriteria, likelyFiles);
+    return {
+        summary: summarizeWorkItem(workItem),
+        acceptanceCriteria,
+        missingQuestions,
+        affectedRepositories: workspaceCandidate
+            ? [{
+                    name: workspaceCandidate.workspace.name,
+                    path: workspaceCandidate.workspace.path,
+                    reasons: workspaceCandidate.reasons.slice(0, 6)
+                }]
+            : [],
+        likelyFiles,
+        linkedReferences,
+        dependencies,
+        risks,
+        testStrategy: inferTestStrategy(workItem, workspaceCandidate, likelyFiles, repositoryKnowledge),
+        deliveryChecklist: buildDeliveryChecklist(workItem)
+    };
+}
+function summarizeWorkItem(workItem) {
+    const displayType = `${workItem.type.charAt(0).toUpperCase()}${workItem.type.slice(1)}`;
+    const fragments = [
+        `${displayType} ${workItem.key}`,
+        `is currently ${workItem.status}`,
+        workItem.priority ? `with ${workItem.priority} priority` : undefined,
+        `and asks for: ${workItem.title}`
+    ].filter((item) => Boolean(item));
+    return `${fragments.join(" ")}.`;
+}
+function extractAcceptanceCriteria(workItem) {
+    const description = workItem.description?.trim();
+    if (!description) {
+        return [];
+    }
+    const lines = description
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const criteria = [];
+    let collecting = false;
+    for (const line of lines) {
+        const normalized = line.toLowerCase();
+        if (/\b(acceptance criteria|success criteria|definition of done|expected result|expected behavior|validation)\b/u.test(normalized)) {
+            collecting = true;
+            const inline = line.split(/:\s*/u).slice(1).join(":").trim();
+            if (inline) {
+                criteria.push(cleanCriteriaLine(inline));
+            }
+            continue;
+        }
+        if (collecting) {
+            if (/^[a-z][a-z ]{1,30}:$/u.test(normalized) && !/\b(given|when|then|should|must|verify|validate|done|expected)\b/u.test(normalized)) {
+                collecting = false;
+                continue;
+            }
+            if (/^[-*•\d.)\s]+/u.test(line) || /\b(given|when|then|should|must|verify|validate|done when|expected)\b/u.test(normalized)) {
+                criteria.push(cleanCriteriaLine(line));
+            }
+        }
+        else if (/\b(given\b.*\bwhen\b.*\bthen|should|must|verify|validate|done when|expected)\b/su.test(normalized)) {
+            criteria.push(cleanCriteriaLine(line));
+        }
+    }
+    return uniqueStrings(criteria).slice(0, 8);
+}
+function cleanCriteriaLine(line) {
+    return line
+        .replace(/^[-*•\d.)\s]+/u, "")
+        .trim();
+}
+function summarizeLinkedReferences(workItem) {
+    return (workItem.links ?? []).map((link) => ({
+        kind: link.kind,
+        title: link.title ?? link.url,
+        url: link.url
+    })).slice(0, 10);
+}
+function inferLikelyFileHints(workItem, workspaceCandidate, repositoryKnowledge) {
+    const hints = [];
+    const workspace = workspaceCandidate?.workspace;
+    const tokens = tokenizePatchSearchText([
+        workItem.key,
+        workItem.title,
+        workItem.description,
+        ...(workItem.labels ?? []),
+        ...(workItem.components ?? []),
+        ...(repositoryKnowledge?.packageMap.packageNames ?? []),
+        ...(repositoryKnowledge?.moduleBoundaries.map((boundary) => `${boundary.name} ${boundary.path}`) ?? [])
+    ].filter((value) => Boolean(value)).join(" "));
+    for (const link of workItem.links ?? []) {
+        if (link.kind !== "code" && link.kind !== "pull_request") {
+            continue;
+        }
+        const path = inferCodePathFromUrl(link.url);
+        if (path) {
+            hints.push({
+                path,
+                reason: `${link.kind === "pull_request" ? "Linked pull request" : "Linked code"} references this path.`
+            });
+        }
+    }
+    for (const component of workItem.components ?? []) {
+        const slug = slugifyPathSegment(component);
+        if (slug) {
+            hints.push({
+                path: `**/${slug}/**`,
+                reason: `Jira component "${component}" should narrow the code area.`
+            });
+        }
+    }
+    for (const label of workItem.labels ?? []) {
+        const slug = slugifyPathSegment(label);
+        if (slug) {
+            hints.push({
+                path: `**/${slug}/**`,
+                reason: `Jira label "${label}" may map to package, module, or test names.`
+            });
+        }
+    }
+    const title = workItem.title.toLowerCase();
+    if (/\b(test|spec|validation|qa)\b/u.test(title)) {
+        hints.push({ path: "**/*.{test,spec}.*", reason: "Story title mentions tests or validation." });
+    }
+    if (/\b(api|endpoint|controller|route)\b/u.test(title)) {
+        hints.push({ path: "**/{api,routes,controllers}/**", reason: "Story title mentions API or endpoint work." });
+    }
+    if (/\b(ui|screen|page|component|button|form)\b/u.test(title)) {
+        hints.push({ path: "**/{components,pages,app,src}/**", reason: "Story title mentions UI or component work." });
+    }
+    if (/\b(config|setting|env|feature flag|flag)\b/u.test(title)) {
+        hints.push({ path: "**/{config,.github,scripts}/**", reason: "Story title mentions configuration or flags." });
+    }
+    if (workspace?.packageNames?.length) {
+        for (const packageName of workspace.packageNames.slice(0, 4)) {
+            hints.push({
+                path: packageName,
+                reason: "Workspace package metadata is relevant to this task."
+            });
+        }
+    }
+    if (repositoryKnowledge) {
+        for (const boundary of rankKnowledgeModuleBoundaries(repositoryKnowledge, tokens).slice(0, 5)) {
+            hints.push({
+                path: boundary.path,
+                reason: `Repository knowledge identifies ${boundary.kind} boundary "${boundary.name}" as relevant.`
+            });
+        }
+        for (const filePath of rankKnowledgePaths(repositoryKnowledge, tokens).slice(0, 8)) {
+            hints.push({
+                path: filePath,
+                reason: "Repository knowledge matched this tracked path to the story text, labels, components, or plan signals."
+            });
+        }
+    }
+    if (workspace?.path && hints.length === 0) {
+        hints.push({
+            path: workspace.path,
+            reason: "Selected workspace is the current best code context; repository knowledge will narrow files further."
+        });
+    }
+    return uniqueFileHints(hints).slice(0, 10);
+}
+function rankKnowledgeModuleBoundaries(repositoryKnowledge, tokens) {
+    return repositoryKnowledge.moduleBoundaries
+        .map((boundary) => ({
+        boundary,
+        score: scoreKnowledgeText(`${boundary.name} ${boundary.path} ${boundary.kind}`, tokens)
+    }))
+        .filter((candidate) => candidate.score > 0)
+        .sort((left, right) => right.score - left.score || left.boundary.path.localeCompare(right.boundary.path))
+        .map((candidate) => candidate.boundary);
+}
+function rankKnowledgePaths(repositoryKnowledge, tokens) {
+    return [
+        ...repositoryKnowledge.pathMap.source,
+        ...repositoryKnowledge.pathMap.tests,
+        ...repositoryKnowledge.pathMap.config
+    ]
+        .map((filePath) => ({
+        filePath,
+        score: scoreKnowledgeText(filePath, tokens)
+            + (isTestLikeFile(filePath) ? 3 : 0)
+            + (isConfigWorkspacePath(filePath) ? 1 : 0)
+    }))
+        .filter((candidate) => candidate.score > 0)
+        .sort((left, right) => right.score - left.score || left.filePath.localeCompare(right.filePath))
+        .map((candidate) => candidate.filePath);
+}
+function scoreKnowledgeText(value, tokens) {
+    const lower = value.toLowerCase();
+    let score = 0;
+    for (const token of tokens) {
+        if (token.length >= 3 && lower.includes(token)) {
+            score += token.includes("/") ? 8 : 4;
+        }
+    }
+    return score;
+}
+function inferDependencySignals(workItem, workspaceCandidate, repositoryKnowledge) {
+    const workspace = workspaceCandidate?.workspace;
+    const signals = [
+        workItem.parentKey ? `Parent work item: ${workItem.parentKey}` : undefined,
+        workItem.subtasks?.length ? `Subtasks: ${workItem.subtasks.map((subtask) => `${subtask.key} ${subtask.status}`).join(", ")}` : undefined,
+        workItem.components?.length ? `Components: ${workItem.components.join(", ")}` : undefined,
+        workItem.labels?.length ? `Labels: ${workItem.labels.join(", ")}` : undefined,
+        workspace?.packageNames?.length ? `Workspace packages: ${workspace.packageNames.slice(0, 8).join(", ")}` : undefined,
+        workspace?.codeownersKeywords?.length ? `Ownership signals: ${workspace.codeownersKeywords.slice(0, 8).join(", ")}` : undefined,
+        workspace?.recentCommitRefs?.length ? `Recent related work refs: ${workspace.recentCommitRefs.slice(0, 8).join(", ")}` : undefined,
+        repositoryKnowledge?.moduleBoundaries.length
+            ? `Module boundaries: ${repositoryKnowledge.moduleBoundaries.slice(0, 8).map((boundary) => `${boundary.kind}:${boundary.path}`).join(", ")}`
+            : undefined,
+        repositoryKnowledge?.ownership.owners.length ? `Code owners: ${repositoryKnowledge.ownership.owners.slice(0, 8).join(", ")}` : undefined,
+        repositoryKnowledge?.packageMap.validateCommands.length
+            ? `Validation commands: ${repositoryKnowledge.packageMap.validateCommands.join(", ")}`
+            : undefined
+    ];
+    return signals.filter((signal) => Boolean(signal)).slice(0, 10);
+}
+function inferWorkItemRisks(workItem, workspaceCandidate, acceptanceCriteria, likelyFiles) {
+    const risks = [
+        !workspaceCandidate ? "No codebase is selected yet; implementation cannot safely start." : undefined,
+        workspaceCandidate && workspaceCandidate.confidence < 0.6 ? "Codebase match is weak; confirm workspace before editing files." : undefined,
+        acceptanceCriteria.length === 0 ? "Acceptance criteria are not explicit; confirm completion rules before coding." : undefined,
+        likelyFiles.length === 0 ? "No likely files were identified; repository knowledge should be built before a broad change." : undefined,
+        /high|highest|blocker|critical/u.test((workItem.priority ?? "").toLowerCase()) ? `Priority is ${workItem.priority}; keep the change small and validation evidence strong.` : undefined,
+        workItem.type === "bug" && detectMissingRequirementSignals(workItem).some((signal) => signal.includes("reproduction")) ? "Bug report lacks a clear reproduction path." : undefined,
+        (workItem.subtasks?.length ?? 0) > 0 ? "Subtasks may affect delivery order and Jira completion update." : undefined
+    ];
+    return risks.filter((risk) => Boolean(risk)).slice(0, 8);
+}
+function inferTestStrategy(workItem, workspaceCandidate, likelyFiles, repositoryKnowledge) {
+    const strategy = [
+        workspaceCandidate?.workspace.path ? "Discover validation commands from the selected workspace." : "Resolve a workspace before selecting tests.",
+        repositoryKnowledge?.packageMap.validateCommands.length
+            ? `Prefer repository validation: ${repositoryKnowledge.packageMap.validateCommands.slice(0, 3).join(", ")}.`
+            : undefined,
+        repositoryKnowledge?.packageMap.testCommands.length
+            ? `Run test command candidates: ${repositoryKnowledge.packageMap.testCommands.slice(0, 3).join(", ")}.`
+            : undefined,
+        repositoryKnowledge?.pathMap.tests.length
+            ? "Repository knowledge found related test paths; run the narrowest affected test before broad validation."
+            : undefined,
+        likelyFiles.some((file) => /\b(test|spec)\b/u.test(file.path)) ? "Run the related test file candidate first." : undefined,
+        workItem.type === "bug" ? "Add or run a regression test that reproduces the reported behavior." : undefined,
+        workItem.type === "story" || workItem.type === "task" ? "Run the smallest relevant test plus the workspace validation command." : undefined,
+        "Capture test evidence before PR creation.",
+        "If validation fails, use the approved AI retry loop before broadening the patch."
+    ];
+    return strategy.filter((item) => Boolean(item));
+}
+function buildDeliveryChecklist(workItem) {
+    return [
+        `Keep ${workItem.key} in branch, commit, and PR title when possible.`,
+        "Summarize implementation scope in the PR body.",
+        "Include validation evidence from approved test runs.",
+        "Call out risks, missing context, or manual QA needs.",
+        "Post the Jira update only after reviewing the prepared message."
+    ];
+}
+function inferCodePathFromUrl(value) {
+    try {
+        const url = new URL(value);
+        const parts = url.pathname.split("/").filter(Boolean);
+        const markerIndex = parts.findIndex((part) => part === "blob" || part === "tree");
+        if (markerIndex >= 0 && parts.length > markerIndex + 2) {
+            return parts.slice(markerIndex + 2).join("/");
+        }
+    }
+    catch {
+        // Non-URL code references are allowed below.
+    }
+    const trimmed = value.trim();
+    if (/^[\w./-]+\.[a-z0-9]+(?::\d+)?$/iu.test(trimmed) && !trimmed.includes("://")) {
+        return trimmed.replace(/:\d+$/u, "");
+    }
+    return undefined;
+}
+function slugifyPathSegment(value) {
+    const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-|-$/gu, "");
+    return slug.length >= 3 ? slug : undefined;
+}
+function uniqueFileHints(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const key = value.path.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(value);
+    }
+    return result;
+}
 function hasExplicitAcceptanceCriteria(workItem) {
     const text = [workItem.title, workItem.description].filter(Boolean).join("\n").toLowerCase();
     return /\b(acceptance criteria|acceptance|criteria|given\b.*\bwhen\b.*\bthen|expected result|definition of done|done when|should|expected behavior|success criteria|verify|validation)\b/su.test(text);
@@ -3097,6 +3741,19 @@ const sensitiveContentPatterns = [
 ];
 async function collectPatchContextFiles(workspacePath, session) {
     const candidates = [];
+    const tokens = tokenizePatchSearchText([
+        session.workItem.key,
+        session.workItem.title,
+        session.workItem.description,
+        session.plan?.summary,
+        ...(session.plan?.steps.map((step) => `${step.title} ${step.detail ?? ""}`) ?? []),
+        ...(session.workItem.labels ?? []),
+        ...(session.workItem.components ?? []),
+        ...(session.workspaceCandidate?.workspace.packageNames ?? []),
+        ...(session.workspaceCandidate?.workspace.readmeKeywords ?? []),
+        ...(session.repositoryKnowledge?.packageMap.packageNames ?? []),
+        ...(session.repositoryKnowledge?.moduleBoundaries.map((boundary) => `${boundary.name} ${boundary.path}`) ?? [])
+    ].filter((value) => Boolean(value)).join(" "));
     for (const filePath of session.plan?.filesLikelyChanged ?? []) {
         const normalized = normalizeWorkspaceRelativePath(workspacePath, filePath, "skip");
         if (normalized && normalized !== ".") {
@@ -3108,18 +3765,33 @@ async function collectPatchContextFiles(workspacePath, session) {
         }
     }
     candidates.push({ filePath: "package.json", score: 24, reason: "Package metadata helps infer scripts, package boundaries, and runtime." }, { filePath: "README.md", score: 18, reason: "README gives repository purpose and local validation hints." }, { filePath: "AGENTS.md", score: 18, reason: "Agent instructions constrain safe implementation style." }, { filePath: "CODEOWNERS", score: 14, reason: "Ownership metadata helps identify relevant domains and review paths." });
+    if (session.repositoryKnowledge) {
+        for (const boundary of rankKnowledgeModuleBoundaries(session.repositoryKnowledge, tokens).slice(0, 8)) {
+            candidates.push({
+                filePath: boundary.path,
+                score: 34,
+                reason: `Repository knowledge selected ${boundary.kind} boundary "${boundary.name}".`
+            });
+        }
+        for (const filePath of rankKnowledgePaths(session.repositoryKnowledge, tokens).slice(0, 30)) {
+            candidates.push({
+                filePath,
+                score: 32 + scorePatchContextFile(filePath, tokens, new Set()),
+                reason: "Repository knowledge ranked this tracked file for the current story."
+            });
+        }
+        for (const filePath of [
+            ...session.repositoryKnowledge.pathMap.config.slice(0, 12),
+            ...session.repositoryKnowledge.pathMap.tests.slice(0, 12)
+        ]) {
+            candidates.push({
+                filePath,
+                score: 18,
+                reason: "Repository knowledge includes this as relevant configuration or validation context."
+            });
+        }
+    }
     const trackedFiles = await listTrackedWorkspaceFiles(workspacePath);
-    const tokens = tokenizePatchSearchText([
-        session.workItem.key,
-        session.workItem.title,
-        session.workItem.description,
-        session.plan?.summary,
-        ...(session.plan?.steps.map((step) => `${step.title} ${step.detail ?? ""}`) ?? []),
-        ...(session.workItem.labels ?? []),
-        ...(session.workItem.components ?? []),
-        ...(session.workspaceCandidate?.workspace.packageNames ?? []),
-        ...(session.workspaceCandidate?.workspace.readmeKeywords ?? [])
-    ].filter((value) => Boolean(value)).join(" "));
     const planHints = new Set((session.plan?.filesLikelyChanged ?? [])
         .map((filePath) => normalizeWorkspaceRelativePath(workspacePath, filePath, "skip"))
         .filter((filePath) => Boolean(filePath)));
@@ -3180,10 +3852,21 @@ async function listTrackedWorkspaceFiles(workspacePath) {
         .slice(0, 1000);
     return trackedFiles.length > 0 ? trackedFiles : listWorkspaceFilesFallback(workspacePath);
 }
-async function listWorkspaceFilesFallback(workspacePath) {
+async function listWorkspaceFilesForKnowledge(workspacePath) {
+    const output = await runGit(workspacePath, ["ls-files"]);
+    const trackedFiles = output
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((filePath) => !filePath.startsWith(".git/") && !filePath.startsWith("node_modules/") && !filePath.startsWith(".pome/"))
+        .slice(0, 2000);
+    return trackedFiles.length > 0 ? trackedFiles : listWorkspaceFilesFallback(workspacePath, { includeGenerated: true, includeSensitive: true });
+}
+async function listWorkspaceFilesFallback(workspacePath, options = {}) {
     const collected = [];
     const queue = ["."];
-    const ignoredDirectories = new Set([".git", "node_modules", "dist", "build", "coverage", ".next", ".turbo", ".cache", "vendor"]);
+    const ignoredDirectories = new Set([".git", ".pome", "node_modules", "vendor"]);
+    const generatedDirectories = new Set(["dist", "build", "coverage", ".next", ".turbo", ".cache", "out", "target", "generated", "__generated__"]);
     while (queue.length > 0 && collected.length < 1000) {
         const current = queue.shift() ?? ".";
         const absoluteCurrent = resolve(workspacePath, current);
@@ -3197,12 +3880,15 @@ async function listWorkspaceFilesFallback(workspacePath) {
         for await (const entry of directory) {
             const relativePath = current === "." ? entry.name : `${current}/${entry.name}`;
             if (entry.isDirectory()) {
-                if (!ignoredDirectories.has(entry.name) && !isSensitiveWorkspacePath(relativePath)) {
+                const shouldSkipGenerated = !options.includeGenerated && generatedDirectories.has(entry.name);
+                const shouldSkipSensitive = !options.includeSensitive && isSensitiveWorkspacePath(relativePath);
+                if (!ignoredDirectories.has(entry.name) && !shouldSkipGenerated && !shouldSkipSensitive) {
                     queue.push(relativePath);
                 }
                 continue;
             }
-            if (entry.isFile() && !isSensitiveWorkspacePath(relativePath)) {
+            const shouldSkipSensitive = !options.includeSensitive && isSensitiveWorkspacePath(relativePath);
+            if (entry.isFile() && !shouldSkipSensitive) {
                 collected.push(relativePath);
                 if (collected.length >= 1000) {
                     break;
@@ -3276,6 +3962,7 @@ function buildStructuredPatchPrompt(session, workspacePath, contextFiles) {
         ...(plan?.missingInfo ?? [])
     ])).slice(0, 8);
     const workspace = session.workspaceCandidate?.workspace;
+    const knowledge = session.repositoryKnowledge;
     return [
         "You are OpenPome's implementation engine.",
         failedTestContext.length
@@ -3322,6 +4009,18 @@ function buildStructuredPatchPrompt(session, workspacePath, contextFiles) {
         workspace?.recentBranches?.length ? `- Recent branches: ${workspace.recentBranches.slice(0, 8).join(", ")}` : undefined,
         workspace?.recentCommitRefs?.length ? `- Recent work refs: ${workspace.recentCommitRefs.slice(0, 12).join(", ")}` : undefined,
         "",
+        knowledge ? "Repository knowledge:" : undefined,
+        knowledge ? `- Knowledge file: ${knowledge.knowledgeFile}` : undefined,
+        knowledge ? `- Package manager: ${knowledge.packageMap.packageManager}` : undefined,
+        knowledge?.packageMap.packageNames.length ? `- Packages: ${knowledge.packageMap.packageNames.slice(0, 12).join(", ")}` : undefined,
+        knowledge?.moduleBoundaries.length
+            ? `- Module boundaries: ${knowledge.moduleBoundaries.slice(0, 12).map((boundary) => `${boundary.kind}:${boundary.path}`).join("; ")}`
+            : undefined,
+        knowledge ? `- Path map: ${knowledge.pathMap.source.length} source, ${knowledge.pathMap.tests.length} test, ${knowledge.pathMap.config.length} config, ${knowledge.pathMap.generated.length} generated, ${knowledge.pathMap.sensitive.length} sensitive` : undefined,
+        knowledge?.ownership.owners.length ? `- Code owners: ${knowledge.ownership.owners.slice(0, 12).join(", ")}` : undefined,
+        knowledge?.packageMap.validateCommands.length ? `- Validation commands: ${knowledge.packageMap.validateCommands.join(", ")}` : undefined,
+        knowledge?.packageMap.testCommands.length ? `- Test commands: ${knowledge.packageMap.testCommands.join(", ")}` : undefined,
+        knowledge ? "" : undefined,
         "Readable context files:",
         context || "No source files were safely included. You may propose small new files only if the task clearly asks for them."
     ].filter((line) => Boolean(line)).join("\n");
@@ -3502,7 +4201,9 @@ async function discoverTestCommandCandidates(workspacePath, session) {
 async function findRelatedTestFiles(workspacePath, session) {
     let trackedFiles = [];
     try {
-        trackedFiles = await listTrackedWorkspaceFiles(workspacePath);
+        trackedFiles = session.repositoryKnowledge?.pathMap.tests.length
+            ? session.repositoryKnowledge.pathMap.tests
+            : await listTrackedWorkspaceFiles(workspacePath);
     }
     catch {
         return [];
@@ -3518,6 +4219,8 @@ async function findRelatedTestFiles(workspacePath, session) {
             session.workItem.description,
             ...(session.workItem.labels ?? []),
             ...(session.workItem.components ?? []),
+            ...(session.repositoryKnowledge?.packageMap.packageNames ?? []),
+            ...(session.repositoryKnowledge?.moduleBoundaries.map((boundary) => `${boundary.name} ${boundary.path}`) ?? []),
             session.plan?.summary
         ].filter((value) => Boolean(value)).join(" "))
     ]);