@unbrained/pm-cli 2026.7.13 → 2026.7.14

package/dist/cli-bundle/chunks/{chunk-ZTSV7P2T.js → chunk-BPD26E3P.js}

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="410e9d5d-955a-5e65-9b6b-f17dc7a2cf71")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ebd76eb4-36dd-5cd4-a772-a83b5dddeb05")}catch(e){}}();
 import {
   collectRuntimeFilterValues,
   createQueryFingerprint,
@@ -7,20 +7,24 @@ import {
   matchesRuntimeFilters,
   resolveQueryCursorStart,
   runList
-} from "./chunk-2PR4ZTRO.js";
+} from "./chunk-6TTOHMTB.js";
 import {
   collectBlockedByIds,
   computeActionabilityReport
-} from "./chunk-KR5EHAN4.js";
+} from "./chunk-X3GYR4P2.js";
 import {
   parseIntegerLimit,
   parsePriority,
   parseType,
   readHistoryEntries
-} from "./chunk-YFGYDZRP.js";
+} from "./chunk-2GA3NK35.js";
 import {
   parseLimit
-} from "./chunk-VDAZPPRU.js";
+} from "./chunk-3I3LRT2G.js";
+import {
+  readContextUsageAffinity,
+  recordContextUsageServing
+} from "./chunk-ZNP64HOW.js";
 import {
   compareTimestampStrings,
   enforceHistoryStreamPolicyForItems,
@@ -34,7 +38,7 @@ import {
   resolveIsoOrRelative,
   runActiveOnReadHooks,
   runActiveServiceOverride
-} from "./chunk-TNGLCRKS.js";
+} from "./chunk-GSEADLRH.js";
 import {
   CONTEXT_DEPTH_VALUES,
   CONTEXT_SECTION_VALUES,
@@ -49,7 +53,7 @@ import {
   resolveRuntimeFieldRegistry,
   resolveRuntimeStatusRegistry,
   weekdayOrderIndex
-} from "./chunk-TGG7YGMC.js";
+} from "./chunk-GXXC7QSK.js";
 
 // dist/cli/commands/activity.js
 import fs from "node:fs/promises";
@@ -1105,6 +1109,7 @@ var CONTEXT_RELEVANCE_SIGNAL_NAMES = [
   "deadline_pressure",
   "knowledge_density",
   "author_affinity",
+  "usage_affinity",
   "semantic_similarity"
 ];
 var CONTEXT_RELEVANCE_SERVICE = "context_relevance";
@@ -1119,6 +1124,7 @@ var DEFAULT_CONTEXT_RELEVANCE_WEIGHTS = {
   deadline_pressure: 0.45,
   knowledge_density: 0.25,
   author_affinity: 0.2,
+  usage_affinity: 0.3,
   semantic_similarity: 0.5
 };
 var JSON_TOKEN_ENCODER = new TextEncoder();
@@ -1379,6 +1385,181 @@ async function runContextEvaluationCorpus(scenarios, reader, thresholds) {
   return summarizeContextEvaluationReports(reports, thresholds);
 }
 
+// dist/sdk/context-packing.js
+var CONTEXT_PACKING_PROFILES = {
+  balanced: { redundancyPenalty: 0.35, uncertaintyPenalty: 0.2 },
+  context: { redundancyPenalty: 0.45, uncertaintyPenalty: 0.15 },
+  next: { redundancyPenalty: 0.25, uncertaintyPenalty: 0.3 }
+};
+var PROJECTION_LEVELS = [
+  "identity",
+  "summary",
+  "full"
+];
+function assertPackingCandidate(candidate) {
+  if (!candidate.id.trim() || !Number.isInteger(candidate.rank) || candidate.rank < 1) {
+    throw new TypeError("Context packing candidates require a non-empty id and positive integer rank");
+  }
+  if (!Number.isFinite(candidate.score) || candidate.score < 0) {
+    throw new TypeError("Context packing candidate scores must be finite and non-negative");
+  }
+  const costs = PROJECTION_LEVELS.map((level) => candidate.token_costs[level]);
+  if (costs.some((cost) => !Number.isInteger(cost) || cost < 1) || costs[0] > costs[1] || costs[1] > costs[2]) {
+    throw new TypeError("Context projection costs must be positive monotone integers");
+  }
+  if (candidate.uncertainty !== void 0 && (!Number.isFinite(candidate.uncertainty) || candidate.uncertainty < 0)) {
+    throw new TypeError("Context packing uncertainty must be finite and non-negative");
+  }
+}
+function resolvePackingPenalties(options) {
+  if (!Number.isInteger(options.tokenBudget) || options.tokenBudget < 1) {
+    throw new TypeError("Context packing tokenBudget must be a positive integer");
+  }
+  const profile = options.profile ?? "balanced";
+  const policy = CONTEXT_PACKING_PROFILES[profile];
+  if (!policy)
+    throw new TypeError("Unknown context packing profile");
+  const redundancy = options.redundancyPenalty ?? policy.redundancyPenalty;
+  const uncertainty = options.uncertaintyPenalty ?? policy.uncertaintyPenalty;
+  if (!Number.isFinite(redundancy) || redundancy < 0 || redundancy > 1 || !Number.isFinite(uncertainty) || uncertainty < 0) {
+    throw new TypeError("Context packing penalties must be finite and within their supported ranges");
+  }
+  if (options.latencyBudgetMs !== void 0 && (!Number.isFinite(options.latencyBudgetMs) || options.latencyBudgetMs <= 0)) {
+    throw new TypeError("Context packing latencyBudgetMs must be positive");
+  }
+  return { redundancy, uncertainty, profile };
+}
+function orderPackingCandidates(candidates) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    assertPackingCandidate(candidate);
+    if (ids.has(candidate.id)) {
+      throw new TypeError("Context packing candidates require unique ids");
+    }
+    ids.add(candidate.id);
+  }
+  return [...candidates].sort((left, right) => left.rank - right.rank || left.id.localeCompare(right.id));
+}
+function findBestAffordableCandidate(candidates, remaining, valueOf, deadline, readClock) {
+  let bestIndex = -1;
+  let evaluated = 0;
+  for (let index = 0; index < candidates.length; index += 1) {
+    if (index % 128 === 0 && readClock() >= deadline) {
+      return { index: bestIndex, evaluated, timedOut: true };
+    }
+    const candidate = candidates[index];
+    if (candidate.token_costs.identity > remaining)
+      continue;
+    evaluated += 1;
+    const best = bestIndex < 0 ? void 0 : candidates[bestIndex];
+    const density = valueOf(candidate) / candidate.token_costs.identity;
+    const bestDensity = best === void 0 ? Number.NEGATIVE_INFINITY : valueOf(best) / best.token_costs.identity;
+    if (density > bestDensity || density === bestDensity && best !== void 0 && (candidate.rank < best.rank || candidate.rank === best.rank && candidate.id.localeCompare(best.id) < 0)) {
+      bestIndex = index;
+    }
+  }
+  return { index: bestIndex, evaluated, timedOut: false };
+}
+function selectIdentityCandidates(params) {
+  const represented = /* @__PURE__ */ new Set();
+  const included = [];
+  let remaining = params.tokenBudget;
+  const valueOf = (candidate) => {
+    const key = candidate.lineage ?? candidate.cluster;
+    const redundancy = key && represented.has(key) ? 1 - params.redundancyPenalty : 1;
+    return Math.max(0, (candidate.score - params.uncertaintyPenalty * (candidate.uncertainty ?? 0)) * redundancy);
+  };
+  const admit = (candidate) => {
+    const tokens = candidate.token_costs.identity;
+    included.push({
+      ...candidate,
+      projection: "identity",
+      tokens,
+      marginal_value: valueOf(candidate)
+    });
+    remaining -= tokens;
+    const key = candidate.lineage ?? candidate.cluster;
+    if (key)
+      represented.add(key);
+  };
+  for (const candidate of params.ordered.filter((entry) => entry.required)) {
+    if (candidate.token_costs.identity <= remaining)
+      admit(candidate);
+  }
+  const optional = params.ordered.filter((entry) => !entry.required);
+  let selectionComplete = true;
+  let evaluatedCandidates = 0;
+  while (optional.length > 0) {
+    const selection = findBestAffordableCandidate(optional, remaining, valueOf, params.deadline, params.readClock);
+    evaluatedCandidates += selection.evaluated;
+    if (selection.timedOut)
+      selectionComplete = false;
+    if (selection.index < 0 || selection.timedOut)
+      break;
+    admit(optional.splice(selection.index, 1)[0]);
+  }
+  return {
+    included,
+    remaining,
+    selectionComplete,
+    evaluatedCandidates
+  };
+}
+function upgradeSelectedProjections(included, initialRemaining) {
+  let remaining = initialRemaining;
+  for (const target of ["summary", "full"]) {
+    const previous = target === "summary" ? "identity" : "summary";
+    const upgrades = [...included].sort((left, right) => {
+      const leftCost = left.token_costs[target] - left.token_costs[previous];
+      const rightCost = right.token_costs[target] - right.token_costs[previous];
+      return right.marginal_value / Math.max(rightCost, 1) - left.marginal_value / Math.max(leftCost, 1) || left.rank - right.rank || left.id.localeCompare(right.id);
+    });
+    for (const entry of upgrades) {
+      if (entry.projection !== previous)
+        continue;
+      const extra = entry.token_costs[target] - entry.tokens;
+      if (extra > remaining)
+        continue;
+      entry.projection = target;
+      entry.tokens += extra;
+      remaining -= extra;
+    }
+  }
+  return remaining;
+}
+function packContextCandidates(candidates, options) {
+  const penalties = resolvePackingPenalties(options);
+  const ordered = orderPackingCandidates(candidates);
+  const readClock = options.readClock ?? performance.now.bind(performance);
+  const deadline = options.latencyBudgetMs === void 0 ? Number.POSITIVE_INFINITY : readClock() + options.latencyBudgetMs;
+  const selection = selectIdentityCandidates({
+    ordered,
+    tokenBudget: options.tokenBudget,
+    redundancyPenalty: penalties.redundancy,
+    uncertaintyPenalty: penalties.uncertainty,
+    deadline,
+    readClock
+  });
+  const { included } = selection;
+  const remaining = upgradeSelectedProjections(included, selection.remaining);
+  included.sort((left, right) => left.rank - right.rank || left.id.localeCompare(right.id));
+  const selected = new Set(included.map((entry) => entry.id));
+  return {
+    included,
+    omitted_ids: ordered.filter((entry) => !selected.has(entry.id)).map((entry) => entry.id),
+    token_budget: options.tokenBudget,
+    used_tokens: options.tokenBudget - remaining,
+    remaining_tokens: remaining,
+    complete: selection.selectionComplete && included.length === candidates.length && included.every((entry) => entry.projection === "full"),
+    selection_complete: selection.selectionComplete,
+    termination_reason: selection.selectionComplete ? "exhausted" : "latency_budget",
+    evaluated_candidates: selection.evaluatedCandidates,
+    latency_budget_ms: options.latencyBudgetMs ?? null,
+    profile: penalties.profile,
+    degradation_ladder: ["full", "summary", "identity"]
+  };
+}
+
 // dist/cli/commands/context.js
 var CONTEXT_OUTPUT_VALUES = ["markdown", "toon", "json"];
 var HIGH_LEVEL_TYPES = /* @__PURE__ */ new Set(["Epic", "Feature"]);
@@ -1727,11 +1908,12 @@ function buildItemContextRelevanceCandidate(item, params) {
       risk_pressure: riskPressure,
       deadline_pressure: resolveDeadlinePressure(item.deadline, params.nowMs),
       knowledge_density: Math.min(knowledgeEntries / 5, 1),
-      author_affinity: assignedToAuthor ? 1 : 0
+      author_affinity: assignedToAuthor ? 1 : 0,
+      usage_affinity: params.usageAffinity?.[item.id]
     }
   };
 }
-function buildItemContextRelevanceCandidates(items, statusRegistry, now, author) {
+function buildItemContextRelevanceCandidates(items, statusRegistry, now, author, usageAffinity) {
   const recencyOrder = [...items].sort((left, right) => compareTimestampStrings(sortableTimestamp(right.updated_at), sortableTimestamp(left.updated_at)) || left.id.localeCompare(right.id));
   const recencyRank = new Map(recencyOrder.map((item, index) => [item.id, index]));
   const recencyDenominator = Math.max(items.length - 1, 1);
@@ -1743,9 +1925,45 @@ function buildItemContextRelevanceCandidates(items, statusRegistry, now, author)
     normalizedAuthor,
     recencyRank,
     recencyDenominator,
-    itemCount: items.length
+    itemCount: items.length,
+    usageAffinity
   }));
 }
+function estimateJsonTokens2(value) {
+  return Math.max(1, Math.ceil(Buffer.byteLength(JSON.stringify(value), "utf8") / 4));
+}
+function packRankedContextItems(report, tokenBudget, requiredIds = /* @__PURE__ */ new Set(), profile = "context") {
+  return packContextCandidates(report.ranked.map((entry) => ({
+    id: entry.id,
+    item: entry.item,
+    rank: entry.rank,
+    score: entry.score,
+    required: requiredIds.has(entry.id),
+    cluster: entry.item.parent?.trim() || entry.item.type,
+    token_costs: {
+      identity: estimateJsonTokens2({ id: entry.id, title: entry.item.title }),
+      summary: estimateJsonTokens2({
+        id: entry.id,
+        title: entry.item.title,
+        type: entry.item.type,
+        status: entry.item.status,
+        priority: entry.item.priority,
+        parent: entry.item.parent
+      }),
+      full: estimateJsonTokens2(entry.item)
+    }
+  })), { tokenBudget, profile, latencyBudgetMs: 25 });
+}
+function toContextPackingSummary(report) {
+  return {
+    ...report,
+    included: report.included.map((entry) => ({
+      id: entry.id,
+      projection: entry.projection,
+      tokens: entry.tokens
+    }))
+  };
+}
 function toContextRankingSummary(report) {
   return {
     model: report.model,
@@ -2354,22 +2572,35 @@ function resolveContextSubtreeIds(parentScope, fullCorpus) {
   }
   return subtree.ids;
 }
-async function resolveContextFocusGroups(listedItemMetadata, allItems, statusRegistry, sectionsIncluded, limit, now, author, cursor, cursorFingerprint, useBoundedPage) {
+async function resolveContextFocusGroups(listedItemMetadata, allItems, statusRegistry, sectionsIncluded, limit, now, author, cursor, cursorFingerprint, useBoundedPage, pmRoot) {
   const structural = [...listedItemMetadata].sort((left, right) => compareCriticalItems(left, right, statusRegistry));
-  const ranking = await scoreContextCandidatesWithActiveExtensions("context", buildItemContextRelevanceCandidates(structural, statusRegistry, now, author));
+  const usage = await readContextUsageAffinity({
+    pmRoot,
+    author,
+    enabled: process.env.PM_CONTEXT_USAGE_DISABLED !== "1"
+  });
+  const ranking = await scoreContextCandidatesWithActiveExtensions("context", buildItemContextRelevanceCandidates(structural, statusRegistry, now, author, usage.affinity));
   const ranked = ranking.ranked.map((entry) => entry.item);
   const activeStatuses = statusRegistry.active_statuses;
-  const activeItems = ranked.filter((item) => activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
-  const pageStart = useBoundedPage ? resolveQueryCursorStart(activeItems, cursor, cursorFingerprint, (item) => item.id) : 0;
-  const focusPage = useBoundedPage ? activeItems.slice(pageStart, pageStart + limit) : activeItems;
-  const hasMore = useBoundedPage && focusPage.length > 0 && pageStart + focusPage.length < activeItems.length;
+  const rankedActiveItems = ranked.filter((item) => activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
+  const pageStart = useBoundedPage ? resolveQueryCursorStart(rankedActiveItems, cursor, cursorFingerprint, (item) => item.id) : 0;
+  const focusPage = useBoundedPage ? rankedActiveItems.slice(pageStart, pageStart + limit) : rankedActiveItems;
+  const hasMore = useBoundedPage && focusPage.length > 0 && pageStart + focusPage.length < rankedActiveItems.length;
   const nextCursor = hasMore && focusPage.length > 0 ? encodeQueryCursor(cursorFingerprint, focusPage[focusPage.length - 1].id, pageStart + focusPage.length - 1) : void 0;
-  const blockedItems = ranked.filter((item) => statusRegistry.blocked_statuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
+  const rankedBlockedItems = ranked.filter((item) => statusRegistry.blocked_statuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
+  const packingIds = /* @__PURE__ */ new Set([
+    ...focusPage.map((item) => item.id),
+    ...rankedBlockedItems.slice(0, limit).map((item) => item.id)
+  ]);
+  const packing = packRankedContextItems({ ...ranking, ranked: ranking.ranked.filter((entry) => packingIds.has(entry.id)) }, Math.max(256, limit * 160));
+  const packedItems = packing.included.map((entry) => entry.item);
+  const activeItems = packedItems.filter((item) => activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
+  const blockedItems = packedItems.filter((item) => statusRegistry.blocked_statuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
   const childrenByParent = buildChildrenByParent(allItems);
   const focusChildrenByParent = contextNeedsAllItems(sectionsIncluded) ? childrenByParent : void 0;
-  const highLevel = focusPage.filter((item) => HIGH_LEVEL_TYPES.has(item.type)).slice(0, useBoundedPage ? focusPage.length : limit).map((item) => toContextFocusItem(item, statusRegistry, focusChildrenByParent));
-  const lowLevel = focusPage.filter((item) => !HIGH_LEVEL_TYPES.has(item.type)).slice(0, useBoundedPage ? focusPage.length : limit).map((item) => toContextFocusItem(item, statusRegistry, focusChildrenByParent));
-  const blockedFallbackUsed = activeItems.length === 0;
+  const highLevel = activeItems.filter((item) => HIGH_LEVEL_TYPES.has(item.type)).slice(0, useBoundedPage ? focusPage.length : limit).map((item) => toContextFocusItem(item, statusRegistry, focusChildrenByParent));
+  const lowLevel = activeItems.filter((item) => !HIGH_LEVEL_TYPES.has(item.type)).slice(0, useBoundedPage ? focusPage.length : limit).map((item) => toContextFocusItem(item, statusRegistry, focusChildrenByParent));
+  const blockedFallbackUsed = rankedActiveItems.length === 0;
   return {
     activeItems,
     blockedItems,
@@ -2378,6 +2609,7 @@ async function resolveContextFocusGroups(listedItemMetadata, allItems, statusReg
     blockedFallback: blockedFallbackUsed ? blockedItems.slice(0, limit).map((item) => toContextFocusItem(item, statusRegistry, focusChildrenByParent)) : [],
     blockedFallbackUsed,
     ranking,
+    packing,
     pageExtras: {
       ...useBoundedPage ? { applied_limit: limit } : {},
       ...hasMore ? { has_more: true, truncated: true } : {},
@@ -2495,14 +2727,37 @@ function maybeAttachEmptyContextSuggestions(result, activeItems, blockedItems) {
     "pm aggregate for a full project status overview"
   ];
 }
+async function attachContextUsageFeedback(result, focusGroups, pmRoot, author) {
+  try {
+    const included = new Set(focusGroups.packing.included.map((entry) => entry.id));
+    await recordContextUsageServing({
+      pmRoot,
+      author,
+      surface: "context",
+      profile: focusGroups.packing.profile,
+      rows: focusGroups.ranking.ranked.map((entry) => ({
+        id: entry.id,
+        rank: entry.rank,
+        included: included.has(entry.id)
+      })),
+      enabled: process.env.PM_CONTEXT_USAGE_DISABLED !== "1"
+    });
+  } catch {
+    result.warnings = mergeSortedWarnings(result.warnings, [
+      "context_usage_feedback_write_failed"
+    ]);
+  }
+}
 async function runContext(options, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
   const resolvedRuntime = await resolveContextRuntime(options, global);
   const corpus = await loadContextCorpus(options, global, resolvedRuntime);
   const runtime = {
     ...resolvedRuntime,
     limit: resolveContextLimitAtScale(resolvedRuntime.limit, corpus.fullCorpus.length)
   };
-  const focusGroups = await resolveContextFocusGroups(corpus.listedItemMetadata, corpus.allItems, runtime.statusRegistry, runtime.sectionsIncluded, runtime.limit, nowIso(), process.env.PM_AUTHOR, options.after, buildContextCursorFingerprint(options), shouldPageContextFocus(options, corpus.fullCorpus.length));
+  const author = process.env.PM_AUTHOR ?? runtime.settings.author_default;
+  const focusGroups = await resolveContextFocusGroups(corpus.listedItemMetadata, corpus.allItems, runtime.statusRegistry, runtime.sectionsIncluded, runtime.limit, nowIso(), author, options.after, buildContextCursorFingerprint(options), shouldPageContextFocus(options, corpus.fullCorpus.length), pmRoot);
   const agendaContext = await buildContextAgenda(options, global, runtime, corpus.subtreeIds);
   const warnings = mergeSortedWarnings(corpus.listed.warnings, agendaContext.agenda.warnings, focusGroups.ranking.warnings);
   const inProgressCount = countContextStatus(focusGroups.activeItems, normalizeStatusInput("in_progress", runtime.statusRegistry), runtime.statusRegistry);
@@ -2563,12 +2818,15 @@ async function runContext(options, global) {
     ...focusGroups.pageExtras
   };
   attachOptionalContextSections(result, sections);
-  if (options.explainRanking === true)
+  if (options.explainRanking === true) {
     result.ranking = toContextRankingSummary(focusGroups.ranking);
+    result.packing = toContextPackingSummary(focusGroups.packing);
+  }
   applyContextFocusProjection(result, runtime.focusFields);
   if (warnings.length > 0)
     result.warnings = warnings;
   maybeAttachEmptyContextSuggestions(result, focusGroups.activeItems, focusGroups.blockedItems);
+  await attachContextUsageFeedback(result, focusGroups, pmRoot, author);
   return result;
 }
 
@@ -2737,6 +2995,54 @@ function buildNextTruncation(decisionCount, heldCount, limit) {
   }
   return Object.keys(truncation).length > 0 ? truncation : void 0;
 }
+async function attachNextUsageFeedback(params) {
+  try {
+    const included = new Set(params.packing.included.map((entry) => entry.id));
+    await recordContextUsageServing({
+      pmRoot: params.pmRoot,
+      author: params.author,
+      surface: "next",
+      profile: params.packing.profile,
+      rows: params.ranking.ranked.map((entry) => ({
+        id: entry.id,
+        rank: entry.rank,
+        included: included.has(entry.id)
+      })),
+      enabled: process.env.PM_CONTEXT_USAGE_DISABLED !== "1"
+    });
+  } catch {
+    params.result.warnings = [
+      .../* @__PURE__ */ new Set([
+        ...params.result.warnings ?? [],
+        "context_usage_feedback_write_failed"
+      ])
+    ].sort((left, right) => left.localeCompare(right));
+  }
+}
+async function finalizeNextResult(params) {
+  const warnings = [
+    .../* @__PURE__ */ new Set([
+      ...params.candidatesWarnings ?? [],
+      ...params.corpusWarnings ?? [],
+      ...params.readyRanking.warnings ?? []
+    ])
+  ].sort((left, right) => left.localeCompare(right));
+  if (warnings.length > 0)
+    params.result.warnings = warnings;
+  if (params.explainRanking) {
+    params.result.ranking = toContextRankingSummary(params.readyRanking);
+    params.result.packing = toContextPackingSummary(params.packing);
+  }
+  params.result.suggestions = buildNextSuggestions(params.recommended, params.blockedRows);
+  await attachNextUsageFeedback({
+    result: params.result,
+    pmRoot: params.pmRoot,
+    author: params.author,
+    packing: params.packing,
+    ranking: params.readyRanking
+  });
+  return params.result;
+}
 function filterCandidatesByParentScope(candidates, corpus, parentScope) {
   if (!parentScope) {
     return candidates;
@@ -2747,21 +3053,29 @@ function filterCandidatesByParentScope(candidates, corpus, parentScope) {
   }
   return candidates.filter((item) => subtree.ids.has(item.id.trim().toLowerCase()));
 }
-async function rankReadyEntriesWithRelevance(rankedReady, childrenByParent, statusRegistry, now, callerAuthor) {
+async function rankReadyEntriesWithRelevance(rankedReady, childrenByParent, statusRegistry, now, callerAuthor, pmRoot, tokenBudget) {
   const concreteReady = rankedReady.filter((entry) => !hasCompletedDescendants(entry.item, childrenByParent));
   const structuralReady = concreteReady.length > 0 ? concreteReady : rankedReady;
-  const ranking = await scoreContextCandidatesWithActiveExtensions("next", buildItemContextRelevanceCandidates(structuralReady.map((entry) => entry.item), statusRegistry, now, callerAuthor ?? process.env.PM_AUTHOR));
+  const usage = await readContextUsageAffinity({
+    pmRoot,
+    author: callerAuthor,
+    enabled: process.env.PM_CONTEXT_USAGE_DISABLED !== "1"
+  });
+  const ranking = await scoreContextCandidatesWithActiveExtensions("next", buildItemContextRelevanceCandidates(structuralReady.map((entry) => entry.item), statusRegistry, now, callerAuthor, usage.affinity));
+  const packing = packRankedContextItems(ranking, tokenBudget, /* @__PURE__ */ new Set(), "next");
   const readyById = new Map(structuralReady.map((entry) => [entry.item.id, entry]));
   const projectedReady = ranking.ranked.map((entry) => readyById.get(entry.id)).filter((entry) => entry !== void 0);
   return {
     projectedReady,
     ranking,
-    completedContainer: concreteReady.length === 0
+    completedContainer: concreteReady.length === 0,
+    packing
   };
 }
 async function runNext(options, global) {
   const pmRoot = resolvePmRoot(process.cwd(), global.path);
   const settings = await readSettings(pmRoot);
+  const callerAuthor = options.callerAuthor ?? process.env.PM_AUTHOR ?? settings.author_default;
   const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
   const now = nowIso();
   const limit = parseNextLimit(options.limit, "--limit", DEFAULT_NEXT_LIMIT);
@@ -2775,10 +3089,10 @@ async function runNext(options, global) {
   const report = computeActionabilityReport(candidates, corpus, statusRegistry);
   const childrenByParent = buildChildrenByParent(corpus);
   const partitionedByDecision = partitionDecisionEntries(report.ready, options.includeDecisions === true);
-  const callerPartition = partitionCallerOwnedReady(partitionedByDecision.agent, settings.author_default, options.callerAuthor);
+  const callerPartition = partitionCallerOwnedReady(partitionedByDecision.agent, settings.author_default, callerAuthor);
   const rankedReady = rankNextReadyEntries(callerPartition.available, childrenByParent, statusRegistry);
   const rankedBlocked = [...report.blocked].sort((left, right) => compareCriticalItems(left.item, right.item, statusRegistry));
-  const { projectedReady, ranking: readyRanking, completedContainer } = await rankReadyEntriesWithRelevance(rankedReady, childrenByParent, statusRegistry, now, options.callerAuthor);
+  const { projectedReady, ranking: readyRanking, completedContainer, packing: readyPacking } = await rankReadyEntriesWithRelevance(rankedReady, childrenByParent, statusRegistry, now, callerAuthor, pmRoot, Math.max(192, limit * 128));
   const readyRows = projectedReady.map((entry, index) => toNextActionableItem(entry, statusRegistry, childrenByParent, index + 1));
   const blockedRows = rankedBlocked.map((entry, index) => toNextActionableItem(entry, statusRegistry, childrenByParent, index + 1));
   const decisionRows = rankNextReadyEntries(partitionedByDecision.decisions, childrenByParent, statusRegistry).map((entry, index) => toNextActionableItem(entry, statusRegistry, childrenByParent, index + 1));
@@ -2824,19 +3138,18 @@ async function runNext(options, global) {
     },
     truncation
   };
-  const warnings = [
-    .../* @__PURE__ */ new Set([
-      ...candidatesList.warnings ?? [],
-      ...corpusList.warnings ?? [],
-      ...readyRanking.warnings ?? []
-    ])
-  ].sort((a, b) => a.localeCompare(b));
-  if (warnings.length > 0)
-    result.warnings = warnings;
-  if (options.explainRanking === true)
-    result.ranking = toContextRankingSummary(readyRanking);
-  result.suggestions = buildNextSuggestions(recommended, blockedRows);
-  return result;
+  return finalizeNextResult({
+    result,
+    recommended,
+    blockedRows,
+    candidatesWarnings: candidatesList.warnings,
+    corpusWarnings: corpusList.warnings,
+    readyRanking,
+    explainRanking: options.explainRanking === true,
+    pmRoot,
+    author: callerAuthor,
+    packing: readyPacking
+  });
 }
 function renderNextMarkdown(result) {
   const lines = ["# pm next", "", ...renderNextSummaryLines(result)];
@@ -2917,6 +3230,8 @@ export {
   runContextEvaluationScenario,
   summarizeContextEvaluationReports,
   runContextEvaluationCorpus,
+  CONTEXT_PACKING_PROFILES,
+  packContextCandidates,
   CONTEXT_OUTPUT_VALUES,
   resolveContextOutputFormat,
   renderContextMarkdown,
@@ -2927,6 +3242,6 @@ export {
   runNext,
   renderNextMarkdown
 };
-//# sourceMappingURL=chunk-ZTSV7P2T.js.map
+//# sourceMappingURL=chunk-BPD26E3P.js.map
 
-//# debugId=410e9d5d-955a-5e65-9b6b-f17dc7a2cf71
+//# debugId=ebd76eb4-36dd-5cd4-a772-a83b5dddeb05