issue-flow 0.18.0 → 0.19.1

package/dist/chunk-UPAAZU4W.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/execution/registry.ts"],"sourcesContent":["import { readdir } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { listStoredRunSnapshots, type StoredSession } from '../storage/db/repository.js';\nimport { isProcessAlive, isRunLockStale, readRunLock } from '../storage/lock.js';\nimport {\n  type GetGlobalRootOptions,\n  getGlobalRoot,\n  getIssuePaths,\n  PROJECTS_DIR_NAME,\n  RUN_LOCK_FILENAME,\n} from '../storage/paths.js';\nimport type { RunLock } from '../storage/schemas.js';\nimport { readSessionFile } from '../storage/session-file.js';\n\nexport type LiveRunStatus = 'running' | 'unsignaled' | 'orphan';\n\nexport interface LiveRun {\n  projectId: string;\n  target: string;\n  pid: number;\n  host: string;\n  detached: boolean;\n  status: LiveRunStatus;\n  startedAt: string;\n  lastHeartbeatAt: string;\n  issue: number | null;\n  phase: string | null;\n  storiesCompleted: number | null;\n  storiesTotal: number | null;\n  elapsedSeconds: number | null;\n  lockFile: string;\n}\n\nexport function classifyRunLock(lock: RunLock): LiveRunStatus {\n  if (!isProcessAlive(lock.pid)) return 'orphan';\n  if (isRunLockStale(lock)) return 'unsignaled';\n  return 'running';\n}\n\n/**\n * Every run.lock under the global projects tree, enriched from indexed SQLite\n * run/snapshot rows. The lock remains the source of truth for existence and\n * liveness; the database only fills phase and progress.\n */\nexport interface ListLiveRunsOptions extends GetGlobalRootOptions {\n  storageDriver?: 'sqlite' | 'json';\n}\n\nexport async function listLiveRuns(options: ListLiveRunsOptions = {}): Promise<LiveRun[]> {\n  const root = getGlobalRoot(options);\n  const projectsDir = join(root, PROJECTS_DIR_NAME);\n  let projectIds: string[];\n  try {\n    const entries = await readdir(projectsDir, { withFileTypes: true });\n    projectIds = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);\n  } catch {\n    return [];\n  }\n\n  const stored =\n    options.storageDriver === 'json'\n      ? []\n      : await listStoredRunSnapshots({\n          ...(options.env === undefined ? {} : { databaseOptions: { env: options.env } }),\n        }).catch(() => []);\n  const byProjectIssue = new Map(\n    stored.map((session) => [`${session.projectId}:${session.issueId}`, session]),\n  );\n  const runs = await Promise.all(\n    projectIds.map(async (projectId) => {\n      const lockFile = join(projectsDir, projectId, RUN_LOCK_FILENAME);\n      const lock = await readRunLock(lockFile);\n      if (lock === null) return null;\n      const session =\n        options.storageDriver === 'json'\n          ? await readSessionFile(getIssuePaths(projectId, lock.target, options).sessionFile).then(\n              (result) =>\n                result === null\n                  ? undefined\n                  : {\n                      projectId,\n                      issueId: lock.target,\n                      sessionId: String(result.snapshot.sessionId ?? ''),\n                      snapshot: result.snapshot,\n                      updatedAt: new Date(result.updatedAtMs).toISOString(),\n                    },\n            )\n          : byProjectIssue.get(`${projectId}:${lock.target}`);\n      return enrichRun(projectId, lockFile, lock, session);\n    }),\n  );\n\n  return runs\n    .filter((run): run is LiveRun => run !== null)\n    .sort((a, b) => a.startedAt.localeCompare(b.startedAt));\n}\n\nfunction enrichRun(\n  projectId: string,\n  lockFile: string,\n  lock: RunLock,\n  session: StoredSession | undefined,\n): LiveRun {\n  return {\n    projectId,\n    target: lock.target,\n    pid: lock.pid,\n    host: lock.host,\n    detached: lock.detached === true,\n    status: classifyRunLock(lock),\n    startedAt: lock.startedAt,\n    lastHeartbeatAt: lock.lastHeartbeatAt,\n    issue: session?.snapshot.issue.number ?? numericTarget(lock.target),\n    phase: session?.snapshot.currentPhase ?? null,\n    storiesCompleted: session?.snapshot.progress.storiesCompleted ?? null,\n    storiesTotal: session?.snapshot.progress.storiesTotal ?? null,\n    elapsedSeconds: session?.snapshot.elapsedSeconds ?? null,\n    lockFile,\n  };\n}\n\nfunction numericTarget(target: string): number | null {\n  return /^\\d+$/.test(target) ? Number(target) : null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,SAAS,eAAe;AACxB,SAAS,YAAY;AAgCd,SAAS,gBAAgB,MAA8B;AAC5D,MAAI,CAAC,eAAe,KAAK,GAAG,EAAG,QAAO;AACtC,MAAI,eAAe,IAAI,EAAG,QAAO;AACjC,SAAO;AACT;AAWA,eAAsB,aAAa,UAA+B,CAAC,GAAuB;AACxF,QAAM,OAAO,cAAc,OAAO;AAClC,QAAM,cAAc,KAAK,MAAM,iBAAiB;AAChD,MAAI;AACJ,MAAI;AACF,UAAM,UAAU,MAAM,QAAQ,aAAa,EAAE,eAAe,KAAK,CAAC;AAClE,iBAAa,QAAQ,OAAO,CAAC,UAAU,MAAM,YAAY,CAAC,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI;AAAA,EACvF,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,SACJ,QAAQ,kBAAkB,SACtB,CAAC,IACD,MAAM,uBAAuB;AAAA,IAC3B,GAAI,QAAQ,QAAQ,SAAY,CAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,QAAQ,IAAI,EAAE;AAAA,EAC/E,CAAC,EAAE,MAAM,MAAM,CAAC,CAAC;AACvB,QAAM,iBAAiB,IAAI;AAAA,IACzB,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,QAAQ,SAAS,IAAI,QAAQ,OAAO,IAAI,OAAO,CAAC;AAAA,EAC9E;AACA,QAAM,OAAO,MAAM,QAAQ;AAAA,IACzB,WAAW,IAAI,OAAO,cAAc;AAClC,YAAM,WAAW,KAAK,aAAa,WAAW,iBAAiB;AAC/D,YAAM,OAAO,MAAM,YAAY,QAAQ;AACvC,UAAI,SAAS,KAAM,QAAO;AAC1B,YAAM,UACJ,QAAQ,kBAAkB,SACtB,MAAM,gBAAgB,cAAc,WAAW,KAAK,QAAQ,OAAO,EAAE,WAAW,EAAE;AAAA,QAChF,CAAC,WACC,WAAW,OACP,SACA;AAAA,UACE;AAAA,UACA,SAAS,KAAK;AAAA,UACd,WAAW,OAAO,OAAO,SAAS,aAAa,EAAE;AAAA,UACjD,UAAU,OAAO;AAAA,UACjB,WAAW,IAAI,KAAK,OAAO,WAAW,EAAE,YAAY;AAAA,QACtD;AAAA,MACR,IACA,eAAe,IAAI,GAAG,SAAS,IAAI,KAAK,MAAM,EAAE;AACtD,aAAO,UAAU,WAAW,UAAU,MAAM,OAAO;AAAA,IACrD,CAAC;AAAA,EACH;AAEA,SAAO,KACJ,OAAO,CAAC,QAAwB,QAAQ,IAAI,EAC5C,KAAK,CAAC,GAAG,MAAM,EAAE,UAAU,cAAc,EAAE,SAAS,CAAC;AAC1D;AAEA,SAAS,UACP,WACA,UACA,MACA,SACS;AACT,SAAO;AAAA,IACL;AAAA,IACA,QAAQ,KAAK;AAAA,IACb,KAAK,KAAK;AAAA,IACV,MAAM,KAAK;AAAA,IACX,UAAU,KAAK,aAAa;AAAA,IAC5B,QAAQ,gBAAgB,IAAI;AAAA,IAC5B,WAAW,KAAK;AAAA,IAChB,iBAAiB,KAAK;AAAA,IACtB,OAAO,SAAS,SAAS,MAAM,UAAU,cAAc,KAAK,MAAM;AAAA,IAClE,OAAO,SAAS,SAAS,gBAAgB;AAAA,IACzC,kBAAkB,SAAS,SAAS,SAAS,oBAAoB;AAAA,IACjE,cAAc,SAAS,SAAS,SAAS,gBAAgB;AAAA,IACzD,gBAAgB,SAAS,SAAS,kBAAkB;AAAA,IACpD;AAAA,EACF;AACF;AAEA,SAAS,cAAc,QAA+B;AACpD,SAAO,QAAQ,KAAK,MAAM,IAAI,OAAO,MAAM,IAAI;AACjD;","names":[]}

package/dist/{chunk-L6HSKTQE.js → chunk-W7LZLJAF.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/verify/contract.ts
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { join } from "path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
 var DISCOVERABLE = ["typecheck", "lint", "test"];
 async function discoverFromMakefile(cwd) {
   const makePath = join(cwd, "Makefile");
@@ -74,4 +74,4 @@ async function discoverFromPackage(cwd) {
 export {
   resolveContract
 };
-//# sourceMappingURL=chunk-L6HSKTQE.js.map
+//# sourceMappingURL=chunk-W7LZLJAF.js.map

package/dist/{chunk-KMCS76ZW.js → chunk-WB2FVIUS.js}

@@ -2,21 +2,21 @@
 import {
   DEFAULT_BRANCH_CONVENTION,
   loadRepositoryPolicy
-} from "./chunk-LGHND47K.js";
+} from "./chunk-2Q6PG3MT.js";
 import {
   loadPolicyConfig
-} from "./chunk-QF7VEL3M.js";
-import {
-  getBaseBranch
-} from "./chunk-YVPZUN6X.js";
+} from "./chunk-UHDXXLYH.js";
 import {
   getSessionPublisher
-} from "./chunk-DUS5ZNKL.js";
+} from "./chunk-DIMDAYZS.js";
 import {
   hasUsageData,
   isoNow,
   sumUsage
-} from "./chunk-SOM4QA6C.js";
+} from "./chunk-GD7JZMSJ.js";
+import {
+  getBaseBranch
+} from "./chunk-TJVX42KY.js";
 
 // src/core/session-metrics.ts
 function elapsedSecondsSince(startedAtMs) {
@@ -219,7 +219,7 @@ function renderPolicySummary(policy, budgetTokens) {
 
 ${section.body}`;
     const cost = estimateTokens(block);
-    if (used + cost <= budgetTokens) {
+    if (used + cost <= budgetTokens || ["Base branch", "Conventions", "Policy documents"].includes(section.title)) {
       rendered.push(block);
       used += cost;
       continue;
@@ -241,6 +241,7 @@ function policyPlaceholders(policy, options = {}) {
   if (policy === null || !policy.enabled || isEmptyPolicy(policy)) {
     return emptyPolicyPlaceholders();
   }
+  policy = policyForPhase(policy, options.phase);
   const budget = options.budgetTokens ?? DEFAULT_POLICY_CONTEXT_BUDGET;
   return {
     __REPO_POLICY__: renderPolicySummary(policy, budget),
@@ -255,6 +256,30 @@ function policyPlaceholders(policy, options = {}) {
     __REPO_DOCS__: renderDocs(policy.docs)
   };
 }
+function policyForPhase(policy, phase) {
+  if (!phase || phase === "generate" || phase === "analyze") return policy;
+  const publication = phase === "pr" || phase === "pr-review";
+  return {
+    ...policy,
+    issues: {
+      ...policy.issues,
+      templates: publication ? policy.issues.templates : [],
+      types: publication ? policy.issues.types : [],
+      labels: publication ? policy.issues.labels : [],
+      titleConvention: null
+    },
+    pullRequests: {
+      ...policy.pullRequests,
+      template: publication ? policy.pullRequests.template : null,
+      templates: publication ? policy.pullRequests.templates : [],
+      titleConvention: publication ? policy.pullRequests.titleConvention : null
+    },
+    git: {
+      ...policy.git,
+      pullRequestTitleConvention: publication ? policy.git.pullRequestTitleConvention : null
+    }
+  };
+}
 var DEFAULT_POLICY_CONTEXT_BUDGET = 1500;
 function conventionPlaceholders(policy, baseBranchFallback) {
   return {
@@ -269,15 +294,22 @@ async function resolvePolicyPlaceholders(options = {}) {
   let policy = null;
   let projection = emptyPolicyPlaceholders();
   try {
-    policy = await loadRepositoryPolicy({ root: options.root, scope: options.scope ?? null });
+    policy = await loadRepositoryPolicy({
+      root: options.root,
+      scope: options.scope ?? null,
+      remote: options.remote
+    });
     const config = await loadPolicyConfig({ projectRoot: policy.root });
-    projection = policyPlaceholders(policy, { budgetTokens: config.contextBudget });
+    projection = policyPlaceholders(policy, {
+      budgetTokens: config.contextBudget,
+      phase: options.phase
+    });
   } catch {
     policy = null;
   }
   let fallbackBase = "main";
   try {
-    fallbackBase = await getBaseBranch();
+    if (options.remote !== false) fallbackBase = await getBaseBranch();
   } catch {
   }
   return { ...projection, ...conventionPlaceholders(policy, fallbackBase) };
@@ -294,4 +326,4 @@ export {
   publishStoryMetrics,
   resolvePolicyPlaceholders
 };
-//# sourceMappingURL=chunk-KMCS76ZW.js.map
+//# sourceMappingURL=chunk-WB2FVIUS.js.map

package/dist/chunk-WB2FVIUS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/session-metrics.ts","../src/policy/placeholders.ts"],"sourcesContent":["import { type ClaudeUsage, hasUsageData, sumUsage } from './metrics.js';\nimport { getSessionPublisher } from './session-publisher.js';\nimport { isoNow } from './state-manager.js';\n\n/**\n * Publication helper for the single-invocation phases (analyze, generate, prd,\n * plan, review, pr, pr-review).\n *\n * Each of them owns its own `runHeadless` call, so the metrics are published\n * from inside the command rather than from the `instrumentedRunners` wrapper in\n * run.ts: the wrapper only sees `() => Promise<void>` and never touches the\n * HeadlessResult. Publishing here also covers standalone invocations\n * (`issue-flow prd 42`), which never go through the pipeline wrapper at all.\n */\n\n/** Whole seconds elapsed since a `Date.now()` mark, never negative. */\nexport function elapsedSecondsSince(startedAtMs: number): number {\n  return Math.max(0, Math.round((Date.now() - startedAtMs) / 1000));\n}\n\n/**\n * Process-owned totals, accumulated alongside every published event.\n *\n * The session snapshot now stays populated without `--web` (`MemoryPublisher`),\n * but the end-of-run summary box still reads these process-owned counters so a\n * standalone phase command (no publisher installed) does not print zeros.\n *\n * Only phase- and iteration-scoped usage is recorded. Story metrics are a\n * rateio of an iteration already counted here — adding them would double the\n * totals, the same rule the reducer follows.\n */\ninterface UsageAccumulator {\n  all: ClaudeUsage;\n  byPhase: Map<string, ClaudeUsage>;\n  byAgent: Map<string, ClaudeUsage>;\n}\n\nfunction createAccumulator(): UsageAccumulator {\n  return { all: {}, byPhase: new Map(), byAgent: new Map() };\n}\n\n/**\n * Stack of active accumulators, innermost last.\n *\n * The bottom entry is the process total and always exists. A multi-issue run\n * pushes one accumulator per issue (and one for the whole queue) so the terminal\n * summary of issue B never inherits what issue A spent — the leak `core/CLAUDE.md`\n * warned about when it stated that the module-level counters were safe \"only\n * under the current one-issue-per-process model\".\n *\n * Every publication feeds **all** active accumulators, so a scope is a view of\n * the same events rather than a redirection of them.\n */\nconst scopes: UsageAccumulator[] = [createAccumulator()];\n\n/** Innermost active scope: what `run` and the engine report right now. */\nfunction current(): UsageAccumulator {\n  return scopes[scopes.length - 1] as UsageAccumulator;\n}\n\nfunction recordRunUsage(phase: string, usage: ClaudeUsage, providerId?: string): void {\n  for (const scope of scopes) {\n    scope.all = sumUsage(scope.all, usage);\n    scope.byPhase.set(phase, sumUsage(scope.byPhase.get(phase), usage));\n    const agent = providerId ?? 'claude';\n    scope.byAgent.set(agent, sumUsage(scope.byAgent.get(agent), usage));\n  }\n}\n\n/** Everything the innermost active scope has spent, across all phases. */\nexport function getRunUsageTotals(): ClaudeUsage {\n  return { ...current().all };\n}\n\n/** What a single phase has spent so far. Empty when the phase reported nothing. */\nexport function getPhaseUsageTotals(phase: string): ClaudeUsage {\n  return { ...(current().byPhase.get(phase) ?? {}) };\n}\n\n/** A usage scope opened by {@link beginUsageScope}. */\nexport interface UsageScope {\n  /** Everything published while this scope was open. */\n  totals(): ClaudeUsage;\n  /** What one phase published while this scope was open. */\n  phaseTotals(phase: string): ClaudeUsage;\n  /** Close the scope. Idempotent, and safe to call out of order. */\n  end(): ClaudeUsage;\n}\n\n/**\n * Open a nested usage scope, for a run that processes several issues in one\n * process.\n *\n * The scope accumulates only what is published while it is open, which is what\n * lets a queue report a per-issue cost and a consolidated total from the same\n * stream of events. Closing it never discards anything: the outer scopes were\n * fed in parallel.\n */\nexport function beginUsageScope(): UsageScope {\n  const accumulator = createAccumulator();\n  scopes.push(accumulator);\n  let open = true;\n\n  return {\n    totals: () => ({ ...accumulator.all }),\n    phaseTotals: (phase: string) => ({ ...(accumulator.byPhase.get(phase) ?? {}) }),\n    end: () => {\n      if (open) {\n        const index = scopes.indexOf(accumulator);\n        // Never pop the process total, even if a caller double-ends a scope.\n        if (index > 0) scopes.splice(index, 1);\n        open = false;\n      }\n      return { ...accumulator.all };\n    },\n  };\n}\n\n/** Test seam: the counters are module state and must be cleared between runs. */\nexport function resetRunUsageTotals(): void {\n  scopes.splice(0, scopes.length, createAccumulator());\n}\n\n/**\n * Publish one `metrics:update` event of scope `phase` for a headless\n * invocation.\n *\n * A no-op when the CLI reported no usage at all: an event with every field\n * undefined would bump the snapshot version without adding information, and the\n * reducer would leave every counter at null anyway.\n *\n * A command with more than one invocation (the retrying phases, or `review`\n * inside a correction cycle) calls this once per invocation — the reducer's\n * summing is what turns them into the phase total.\n *\n * Never throws and never returns a value: publishing metrics must not be able\n * to change a command's exit code.\n */\nexport function publishPhaseMetrics(\n  phase: string,\n  usage: ClaudeUsage | null | undefined,\n  startedAtMs?: number,\n  providerId?: string,\n): void {\n  if (usage == null || !hasUsageData(usage)) return;\n\n  recordRunUsage(phase, usage, providerId);\n\n  getSessionPublisher().publish({\n    type: 'metrics:update',\n    at: isoNow(),\n    scope: 'phase',\n    phase,\n    ...usage,\n    // Informational only: a phase's durationSeconds keeps coming exclusively\n    // from phase:start/phase:end, so the reducer ignores this for scope 'phase'.\n    durationSeconds: startedAtMs === undefined ? undefined : elapsedSecondsSince(startedAtMs),\n  });\n}\n\n/** The execute loop is the only producer of iteration- and story-scoped metrics. */\nexport const EXECUTE_PHASE = 'execute';\n\n/**\n * Publish one `metrics:update` event of scope `iteration` for a pass of the\n * execute loop.\n *\n * Lands on the `execute` phase and on the issue-wide aggregate, exactly like a\n * phase-scoped event: an iteration *is* a slice of the execute phase. Failed\n * iterations (transient or fatal) publish too — those tokens were spent.\n *\n * A no-op when the CLI reported no usage. Never throws.\n */\nexport function publishIterationMetrics(\n  iteration: number,\n  usage: ClaudeUsage | null | undefined,\n  durationSeconds?: number,\n  providerId?: string,\n): void {\n  if (usage == null || !hasUsageData(usage)) return;\n\n  recordRunUsage(EXECUTE_PHASE, usage, providerId);\n\n  getSessionPublisher().publish({\n    type: 'metrics:update',\n    at: isoNow(),\n    scope: 'iteration',\n    phase: EXECUTE_PHASE,\n    iteration,\n    ...usage,\n    // Informational only: the reducer keeps a phase's durationSeconds coming\n    // exclusively from phase:start/phase:end.\n    durationSeconds,\n  });\n}\n\n/**\n * Publish one `metrics:update` event of scope `story`.\n *\n * The values are the rateio of the iteration that completed the story, so the\n * reducer deliberately keeps them off the phase and the aggregate — the\n * iteration event of the same cycle already counted them there.\n *\n * A no-op when there is neither usage nor a duration to report. Never throws.\n */\nexport function publishStoryMetrics(\n  storyId: string,\n  usage: ClaudeUsage | null | undefined,\n  durationSeconds?: number,\n): void {\n  if (!hasUsageData(usage) && durationSeconds === undefined) return;\n\n  getSessionPublisher().publish({\n    type: 'metrics:update',\n    at: isoNow(),\n    scope: 'story',\n    storyId,\n    ...(usage ?? {}),\n    durationSeconds,\n  });\n}\n","import type { AgentPhase } from '../agents/types.js';\nimport { loadPolicyConfig } from '../config.js';\nimport { DEFAULT_BRANCH_CONVENTION } from '../conventions/git/index.js';\nimport { getBaseBranch } from '../utils/git.js';\nimport { loadRepositoryPolicy } from './resolve.js';\nimport type { IssueTemplate, PolicyDocument, RepositoryPolicy } from './types.js';\n\n/**\n * Projection of a {@link RepositoryPolicy} onto the prompt placeholders.\n *\n * The prompts receive a **summary**, never the raw files. Dumping\n * `CONTRIBUTING.md` and three `AGENTS.md` into every prompt would cost tokens on\n * every single run and drown the actual instruction — and it would duplicate,\n * inside Issue Flow, a rule that already lives in the repository.\n *\n * The whole projection is empty when the repository declares nothing, which is\n * what lets a prompt render byte for byte as it did before this layer existed.\n */\n\n/** Every placeholder this module produces. Ordered as they appear in a prompt. */\nexport const POLICY_PLACEHOLDER_KEYS = [\n  '__REPO_POLICY__',\n  '__REPO_ISSUE_TEMPLATES__',\n  '__REPO_LABELS__',\n  '__REPO_ISSUE_TYPES__',\n  '__REPO_PR_TEMPLATE__',\n  '__REPO_BASE_BRANCH__',\n  '__REPO_CONVENTIONS__',\n  '__REPO_DOCS__',\n] as const;\n\nexport type PolicyPlaceholderKey = (typeof POLICY_PLACEHOLDER_KEYS)[number];\n\n/** Every placeholder empty — the projection of \"this repository declares nothing\". */\nexport function emptyPolicyPlaceholders(): Record<string, string> {\n  return Object.fromEntries(POLICY_PLACEHOLDER_KEYS.map((key) => [key, ''])) as Record<\n    string,\n    string\n  >;\n}\n\n/**\n * Rough token count of a rendered section.\n *\n * Four characters per token is the usual English/Portuguese approximation and is\n * deliberately crude: the budget exists to stop a policy from swallowing the\n * prompt, not to bill anyone. Erring high is the safe direction, so the estimate\n * rounds up.\n */\nexport function estimateTokens(text: string): number {\n  return Math.ceil(text.length / 4);\n}\n\n// ── Section renderers ───────────────────────────────────────────────────────\n\nfunction renderIssueTemplates(templates: IssueTemplate[]): string {\n  if (templates.length === 0) return '';\n\n  const lines = templates.map((template) => {\n    const parts = [`- **${template.name ?? template.path}** (\\`${template.path}\\`)`];\n    if (template.type !== null) parts.push(`type: ${template.type}`);\n    if (template.labels.length > 0) parts.push(`labels: ${template.labels.join(', ')}`);\n    if (template.title !== null) parts.push(`title prefix: \\`${template.title}\\``);\n    if (template.about !== null) parts.push(template.about);\n    return parts.join(' — ');\n  });\n\n  return lines.join('\\n');\n}\n\nfunction renderLabels(policy: RepositoryPolicy): string {\n  if (policy.issues.labels.length === 0) return '';\n\n  return policy.issues.labels\n    .map((label) =>\n      label.description === null ? `- ${label.name}` : `- ${label.name} — ${label.description}`,\n    )\n    .join('\\n');\n}\n\nfunction renderConventions(policy: RepositoryPolicy): string {\n  const rows: string[] = [];\n  if (policy.issues.titleConvention !== null) {\n    rows.push(`- Issue title: ${policy.issues.titleConvention}`);\n  }\n  if (policy.pullRequests.titleConvention !== null) {\n    rows.push(`- Pull Request title: ${policy.pullRequests.titleConvention}`);\n  }\n  if (policy.git.branchConvention !== null) {\n    rows.push(`- Branch: ${policy.git.branchConvention}`);\n  }\n  if (policy.git.commitConvention !== null) {\n    rows.push(`- Commit: ${policy.git.commitConvention}`);\n  }\n  if (policy.git.pullRequestTitleConvention !== null) {\n    rows.push(`- Pull Request title: ${policy.git.pullRequestTitleConvention}`);\n  }\n  if (policy.git.allowedTypes !== null && policy.git.allowedTypes.length > 0) {\n    rows.push(`- Allowed types: ${policy.git.allowedTypes.join(', ')}`);\n  }\n  return rows.join('\\n');\n}\n\n/**\n * Paths of the applicable documents — **never their content**.\n *\n * The agent has `Read` and fetches what it needs. Embedding the documents would\n * multiply the cost of every run and, worse, freeze a copy of the repository's\n * own rule inside a prompt.\n */\nfunction renderDocs(docs: PolicyDocument[]): string {\n  if (docs.length === 0) return '';\n\n  return docs\n    .map((doc) => {\n      const scope = doc.scope === '' ? '' : ` (applies to \\`${doc.scope}/\\`)`;\n      return `- \\`${doc.path}\\`${scope}`;\n    })\n    .join('\\n');\n}\n\n// ── The budgeted summary ────────────────────────────────────────────────────\n\ninterface Section {\n  /** Heading inside the summary. */\n  title: string;\n  body: string;\n  /**\n   * Kept whole even when the budget is blown. The essentials are the taxonomy\n   * an agent cannot guess: it can re-read a document, but it cannot invent the\n   * label a repository actually uses.\n   */\n  essential: boolean;\n  /** Shown in place of the body once the budget is exhausted. */\n  pointer: string;\n}\n\n/**\n * Compose optional policy within `budgetTokens`; mandatory pointers and conventions survive.\n *\n * Sections are added whole, in priority order, while they fit. A section that\n * does not fit is replaced **whole** by a pointer to where the agent can read it\n * — nothing is ever cut mid-sentence, because a summary truncated mid-rule is\n * worse than one that says where the rule lives.\n */\nexport function renderPolicySummary(policy: RepositoryPolicy, budgetTokens: number): string {\n  const sections: Section[] = [\n    {\n      title: 'Base branch',\n      body: policy.pullRequests.baseBranch ?? '',\n      essential: true,\n      pointer: '',\n    },\n    {\n      title: 'Conventions',\n      body: renderConventions(policy),\n      essential: true,\n      pointer: '',\n    },\n    {\n      title: 'Issue Types',\n      body: policy.issues.types.join(', '),\n      essential: true,\n      pointer: '',\n    },\n    {\n      title: 'Issue Templates',\n      body: renderIssueTemplates(policy.issues.templates),\n      essential: true,\n      pointer: 'Run `issue-flow policy --json` to read the templates in full.',\n    },\n    {\n      title: 'Labels',\n      body: renderLabels(policy),\n      essential: true,\n      pointer: 'Run `gh label list` to read the labels of this repository.',\n    },\n    {\n      title: 'Pull Request template',\n      body: policy.pullRequests.templates[0]?.path ?? '',\n      essential: false,\n      pointer: '',\n    },\n    {\n      title: 'Policy documents',\n      body: renderDocs(policy.docs),\n      essential: false,\n      pointer: '',\n    },\n  ];\n\n  const rendered: string[] = [];\n  let used = 0;\n\n  for (const section of sections) {\n    if (section.body.trim() === '') continue;\n\n    const block = `### ${section.title}\\n\\n${section.body}`;\n    const cost = estimateTokens(block);\n\n    if (\n      used + cost <= budgetTokens ||\n      ['Base branch', 'Conventions', 'Policy documents'].includes(section.title)\n    ) {\n      rendered.push(block);\n      used += cost;\n      continue;\n    }\n\n    // Over budget. An essential section keeps its slot as a pointer; a\n    // non-essential optional one drops out. Mandatory pointers above always survive.\n    if (section.essential && section.pointer !== '') {\n      const fallback = `### ${section.title}\\n\\n${section.pointer}`;\n      rendered.push(fallback);\n      used += estimateTokens(fallback);\n    }\n  }\n\n  return rendered.join('\\n\\n');\n}\n\n/** True when the policy carries nothing a prompt could act on. */\nexport function isEmptyPolicy(policy: RepositoryPolicy): boolean {\n  return (\n    policy.issues.templates.length === 0 &&\n    policy.issues.types.length === 0 &&\n    policy.issues.labels.length === 0 &&\n    policy.issues.titleConvention === null &&\n    policy.pullRequests.templates.length === 0 &&\n    policy.pullRequests.baseBranch === null &&\n    policy.pullRequests.titleConvention === null &&\n    policy.git.branchConvention === null &&\n    policy.git.commitConvention === null &&\n    policy.docs.length === 0\n  );\n}\n\nexport interface PolicyPlaceholderOptions {\n  /** Token budget for `__REPO_POLICY__`. Defaults to the resolved configuration. */\n  budgetTokens?: number;\n  phase?: AgentPhase;\n}\n\n/**\n * Project a resolved policy onto the prompt placeholders.\n *\n * A `null` policy — or one that carries nothing — yields every placeholder\n * empty, which is what makes the rendered prompt identical to the pre-policy\n * one. This is the contract the whole feature rests on.\n */\nexport function policyPlaceholders(\n  policy: RepositoryPolicy | null,\n  options: PolicyPlaceholderOptions = {},\n): Record<string, string> {\n  if (policy === null || !policy.enabled || isEmptyPolicy(policy)) {\n    return emptyPolicyPlaceholders();\n  }\n\n  policy = policyForPhase(policy, options.phase);\n  const budget = options.budgetTokens ?? DEFAULT_POLICY_CONTEXT_BUDGET;\n\n  return {\n    __REPO_POLICY__: renderPolicySummary(policy, budget),\n    __REPO_ISSUE_TEMPLATES__: renderIssueTemplates(policy.issues.templates),\n    __REPO_LABELS__: renderLabels(policy),\n    __REPO_ISSUE_TYPES__: policy.issues.types.join(', '),\n    // The one place a whole file is projected verbatim: a Pull Request body has\n    // to *be* the template, so a summary of it would be useless.\n    __REPO_PR_TEMPLATE__: policy.pullRequests.template ?? '',\n    __REPO_BASE_BRANCH__: policy.pullRequests.baseBranch ?? '',\n    __REPO_CONVENTIONS__: renderConventions(policy),\n    __REPO_DOCS__: renderDocs(policy.docs),\n  };\n}\n\n/** Select decision-relevant policy without rediscovering or mutating its source. */\nexport function policyForPhase(policy: RepositoryPolicy, phase?: AgentPhase): RepositoryPolicy {\n  if (!phase || phase === 'generate' || phase === 'analyze') return policy;\n  const publication = phase === 'pr' || phase === 'pr-review';\n  return {\n    ...policy,\n    issues: {\n      ...policy.issues,\n      templates: publication ? policy.issues.templates : [],\n      types: publication ? policy.issues.types : [],\n      labels: publication ? policy.issues.labels : [],\n      titleConvention: null,\n    },\n    pullRequests: {\n      ...policy.pullRequests,\n      template: publication ? policy.pullRequests.template : null,\n      templates: publication ? policy.pullRequests.templates : [],\n      titleConvention: publication ? policy.pullRequests.titleConvention : null,\n    },\n    git: {\n      ...policy.git,\n      pullRequestTitleConvention: publication ? policy.git.pullRequestTitleConvention : null,\n    },\n  };\n}\n\n/** Default token budget for `__REPO_POLICY__`, overridable via `policy.contextBudget`. */\nexport const DEFAULT_POLICY_CONTEXT_BUDGET = 1500;\n\n// ── Conventions that always have a value ────────────────────────────────────\n\nexport { DEFAULT_BRANCH_CONVENTION } from '../conventions/git/index.js';\n\n/**\n * Placeholders that must **never** render empty, because a prompt puts them\n * inside a command it asks the agent to run.\n *\n * `__BASE_BRANCH__` is the reason this group exists separately from the policy\n * projection. `prompts/pr.md` used to spell `main` three times — in\n * `git log main..HEAD`, in `git diff main...HEAD` and in `gh pr create --base\n * main`. In a repository whose base is `develop` that is not a missing feature\n * but an active defect: `main` often *exists* there too, so nothing fails — the\n * agent simply reviews the wrong diff and opens the Pull Request against the\n * wrong target.\n *\n * The resolution order is the repository's declared or discovered base, then\n * `getBaseBranch()`, whose own fallback is `main`. So a repository on `main`\n * renders exactly the text it rendered before.\n */\nexport function conventionPlaceholders(\n  policy: RepositoryPolicy | null,\n  baseBranchFallback: string,\n): Record<string, string> {\n  return {\n    __BASE_BRANCH__: policy?.pullRequests.baseBranch ?? baseBranchFallback,\n    __BRANCH_CONVENTION__: policy?.git.branchConvention ?? DEFAULT_BRANCH_CONVENTION,\n    // The one member of this group that may legitimately render empty: it gates\n    // a conditional section rather than sitting inside a command.\n    __COMMIT_CONVENTION__: policy?.git.commitConvention ?? '',\n  };\n}\n\nexport interface ResolvePolicyPlaceholdersOptions {\n  phase?: AgentPhase;\n  remote?: boolean;\n  /** Repository root. Defaults to the git project root. */\n  root?: string;\n  /** Subdirectory the policy applies to, for monorepos. */\n  scope?: string | null;\n}\n\n/**\n * Resolve the repository policy and project it, in one call.\n *\n * This is what every command uses. It **never throws and never warns**: a\n * repository that is not a git checkout, a discovery that fails, a `gh` that is\n * not installed — all of them yield the empty projection, and the command runs\n * exactly as it did before.\n *\n * The resolution itself is cached per `(root, scope)` by `loadRepositoryPolicy`,\n * so a pipeline that renders eight prompts still discovers once.\n */\nexport async function resolvePolicyPlaceholders(\n  options: ResolvePolicyPlaceholdersOptions = {},\n): Promise<Record<string, string>> {\n  let policy: RepositoryPolicy | null = null;\n  let projection = emptyPolicyPlaceholders();\n  try {\n    policy = await loadRepositoryPolicy({\n      root: options.root,\n      scope: options.scope ?? null,\n      remote: options.remote,\n    });\n    const config = await loadPolicyConfig({ projectRoot: policy.root });\n    projection = policyPlaceholders(policy, {\n      budgetTokens: config.contextBudget,\n      phase: options.phase,\n    });\n  } catch {\n    // Discovery is an enrichment; the conventions below still have to resolve.\n    policy = null;\n  }\n\n  let fallbackBase = 'main';\n  try {\n    if (options.remote !== false) fallbackBase = await getBaseBranch();\n  } catch {\n    // getBaseBranch() does not throw today, but its contract is \"never fails\",\n    // and a base branch that cannot be resolved must not cost the whole prompt.\n  }\n\n  return { ...projection, ...conventionPlaceholders(policy, fallbackBase) };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-SA6HXL4Y.js → chunk-WPHC6JBR.js}

@@ -2,33 +2,33 @@
 import {
   IssueResolutionError,
   resolveIssue
-} from "./chunk-62GVVZQO.js";
+} from "./chunk-3JD25HHJ.js";
 import {
   printError,
   printWarning
-} from "./chunk-XZUEFTUP.js";
+} from "./chunk-J6VJ5M2U.js";
 import {
   actionOf,
   classify,
   requiresHumanAction
-} from "./chunk-XEYH6ZZI.js";
+} from "./chunk-TJVX42KY.js";
 
 // src/issues/context.ts
 function localIssueRef(id) {
   return `issues/${id}/issue.md`;
 }
-function issueReference(issue) {
-  return issue.remoteRef ?? localIssueRef(issue.id);
+function issueReference(issue, localPath) {
+  return issue.remoteRef ?? localPath ?? localIssueRef(issue.id);
 }
 var NO_LABELS = "(none)";
-function issuePlaceholders(resolved) {
+function issuePlaceholders(resolved, localPath) {
   const { issue } = resolved;
   return {
     __ISSUE_TITLE__: issue.title,
     __ISSUE_BODY__: issue.body,
     __ISSUE_LABELS__: issue.labels.length > 0 ? issue.labels.join(", ") : NO_LABELS,
     __ISSUE_SOURCE__: resolved.source,
-    __ISSUE_URL__: issueReference(issue)
+    __ISSUE_URL__: issueReference(issue, localPath)
   };
 }
 async function resolveCommandIssue(id, preResolved, options) {
@@ -64,8 +64,8 @@ function printAction(action) {
 }
 
 export {
-  localIssueRef,
+  issueReference,
   issuePlaceholders,
   resolveCommandIssue
 };
-//# sourceMappingURL=chunk-SA6HXL4Y.js.map
+//# sourceMappingURL=chunk-WPHC6JBR.js.map

package/dist/chunk-WPHC6JBR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/issues/context.ts"],"sourcesContent":["import { actionOf, classify, requiresHumanAction } from '../resilience/errors.js';\nimport { printError, printWarning } from '../ui/logger.js';\nimport { IssueResolutionError, type ResolveIssueOptions, resolveIssue } from './resolver.js';\nimport type { Issue, ResolvedIssue } from './types.js';\n\n/**\n * Bridge between the resolved Issue and the phase prompts.\n *\n * Commands never fetch the Issue themselves: they resolve it once through\n * `resolveIssue` and hand the content to the template, so every phase sees the\n * exact same title/body regardless of where the demand came from.\n */\n\n/** Path of the markdown file a local Issue lives in. */\nexport function localIssueRef(id: string): string {\n  return `issues/${id}/issue.md`;\n}\n\n/**\n * Reference a human (or an agent) can follow to read the Issue: the remote URL\n * when there is one, the local file otherwise.\n */\nexport function issueReference(issue: Issue, localPath?: string): string {\n  return issue.remoteRef ?? localPath ?? localIssueRef(issue.id);\n}\n\n/** Shown instead of an empty list so the prompt never renders a dangling label. */\nconst NO_LABELS = '(none)';\n\n/**\n * Placeholder values every phase template consumes, replacing the former\n * `gh issue view` instruction.\n */\nexport function issuePlaceholders(\n  resolved: ResolvedIssue,\n  localPath?: string,\n): Record<string, string> {\n  const { issue } = resolved;\n  return {\n    __ISSUE_TITLE__: issue.title,\n    __ISSUE_BODY__: issue.body,\n    __ISSUE_LABELS__: issue.labels.length > 0 ? issue.labels.join(', ') : NO_LABELS,\n    __ISSUE_SOURCE__: resolved.source,\n    __ISSUE_URL__: issueReference(issue, localPath),\n  };\n}\n\nexport type CommandIssue = { ok: true; resolved: ResolvedIssue } | { ok: false; code: number };\n\n/**\n * Resolve the Issue a command works on, turning a resolution failure into the\n * exit code the command returns.\n *\n * `preResolved` short-circuits the lookup: the pipeline decides the origin once\n * and passes the decision down, so a phase never re-queries the providers (and\n * never asks the user twice about the same divergence).\n *\n * `options` forwards resolver options — `run.ts` passes the configuration it\n * already loaded so `.issue-flow.json` is read (and warned about) only once.\n */\nexport async function resolveCommandIssue(\n  id: string,\n  preResolved?: ResolvedIssue,\n  options?: ResolveIssueOptions,\n): Promise<CommandIssue> {\n  if (preResolved !== undefined) {\n    return { ok: true, resolved: preResolved };\n  }\n\n  try {\n    return { ok: true, resolved: await resolveIssue(id, options) };\n  } catch (err) {\n    if (err instanceof IssueResolutionError) {\n      printError(err.message);\n      printAction(err.action);\n      return { ok: false, code: err.exitCode };\n    }\n    const message = err instanceof Error ? err.message : String(err);\n    printError(`Could not resolve issue '${id}': ${message}`);\n    printAction(actionOf(err) ?? requiredAction(message));\n    return { ok: false, code: 1 };\n  }\n}\n\n/**\n * What a human has to do about a failure that no amount of waiting fixes.\n *\n * The retry budget was already spent inside the providers — every `gh` call\n * goes through `run()` with the `network`/`rate_limit` policy — so by the time\n * a failure reaches here it is final. What is left to decide is whether it is\n * final *because a person has to act*, and that is what turns an opaque exit\n * code into an instruction.\n */\nfunction requiredAction(message: string): string | null {\n  const failure = classify({ source: 'github', stderr: message });\n  if (!requiresHumanAction(failure.kind)) return null;\n  if (failure.kind === 'authentication') {\n    return 'Run `gh auth login` to authenticate the GitHub CLI';\n  }\n  return null;\n}\n\nfunction printAction(action: string | null | undefined): void {\n  if (action !== null && action !== undefined && action !== '') {\n    printWarning(`Action required: ${action}`);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAcO,SAAS,cAAc,IAAoB;AAChD,SAAO,UAAU,EAAE;AACrB;AAMO,SAAS,eAAe,OAAc,WAA4B;AACvE,SAAO,MAAM,aAAa,aAAa,cAAc,MAAM,EAAE;AAC/D;AAGA,IAAM,YAAY;AAMX,SAAS,kBACd,UACA,WACwB;AACxB,QAAM,EAAE,MAAM,IAAI;AAClB,SAAO;AAAA,IACL,iBAAiB,MAAM;AAAA,IACvB,gBAAgB,MAAM;AAAA,IACtB,kBAAkB,MAAM,OAAO,SAAS,IAAI,MAAM,OAAO,KAAK,IAAI,IAAI;AAAA,IACtE,kBAAkB,SAAS;AAAA,IAC3B,eAAe,eAAe,OAAO,SAAS;AAAA,EAChD;AACF;AAeA,eAAsB,oBACpB,IACA,aACA,SACuB;AACvB,MAAI,gBAAgB,QAAW;AAC7B,WAAO,EAAE,IAAI,MAAM,UAAU,YAAY;AAAA,EAC3C;AAEA,MAAI;AACF,WAAO,EAAE,IAAI,MAAM,UAAU,MAAM,aAAa,IAAI,OAAO,EAAE;AAAA,EAC/D,SAAS,KAAK;AACZ,QAAI,eAAe,sBAAsB;AACvC,iBAAW,IAAI,OAAO;AACtB,kBAAY,IAAI,MAAM;AACtB,aAAO,EAAE,IAAI,OAAO,MAAM,IAAI,SAAS;AAAA,IACzC;AACA,UAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC/D,eAAW,4BAA4B,EAAE,MAAM,OAAO,EAAE;AACxD,gBAAY,SAAS,GAAG,KAAK,eAAe,OAAO,CAAC;AACpD,WAAO,EAAE,IAAI,OAAO,MAAM,EAAE;AAAA,EAC9B;AACF;AAWA,SAAS,eAAe,SAAgC;AACtD,QAAM,UAAU,SAAS,EAAE,QAAQ,UAAU,QAAQ,QAAQ,CAAC;AAC9D,MAAI,CAAC,oBAAoB,QAAQ,IAAI,EAAG,QAAO;AAC/C,MAAI,QAAQ,SAAS,kBAAkB;AACrC,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,SAAS,YAAY,QAAyC;AAC5D,MAAI,WAAW,QAAQ,WAAW,UAAa,WAAW,IAAI;AAC5D,iBAAa,oBAAoB,MAAM,EAAE;AAAA,EAC3C;AACF;","names":[]}