@unbrained/pm-cli 2026.8.10 → 2026.8.12

package/dist/sdk/provenance.d.ts

@@ -5,6 +5,7 @@
  */
 import type { HistoryEntry } from "../types.js";
 import { type HarnessSignalDescriptor } from "../core/shared/author.js";
+import type { AgentModelSource } from "../core/shared/author.js";
 /** One declared provenance dimension and the built-in harnesses that can supply it. */
 export interface AgentProvenanceDescriptorCoverage {
     /** Stable provenance dimension name. */
@@ -36,6 +37,34 @@ export interface AgentProvenanceDimensionCoverage extends AgentModelProvenanceCo
     /** Stable provenance dimension being summarized. */
     dimension: string;
 }
+/** Semantic attribution coverage for one harness and role/topic dimension. */
+export interface AgentSemanticAttributionCoverage {
+    /** Stable detected harness namespace. */
+    harness: string;
+    /** Semantic dimension being measured. */
+    dimension: "role" | "topic";
+    /** History events attributed to the harness. */
+    entries: number;
+    /** Events carrying a non-empty semantic observation. */
+    observed: number;
+    /** Observed events grouped by precedence source. */
+    by_source: Partial<Record<AgentModelSource, number>>;
+    /** Observed fraction across all harness events. */
+    coverage: number;
+}
+/** Result of applying a corpus-facing semantic coverage threshold. */
+export interface AgentSemanticAttributionCoverageGate {
+    /** Whether every sampled harness/dimension row met the threshold. */
+    passed: boolean;
+    /** Required observed fraction. */
+    minimum_coverage: number;
+    /** Required event count before a row participates. */
+    minimum_entries: number;
+    /** Deterministically ordered coverage rows. */
+    rows: AgentSemanticAttributionCoverage[];
+    /** Harness/dimension keys that failed the threshold. */
+    failures: string[];
+}
 /** One declared or inferred episode group with deterministically nested children. */
 export interface AgentEpisodeGroup {
     /** Stable declared or inferred group key. */
@@ -68,6 +97,15 @@ export declare function summarizeAgentModelProvenance(entries: readonly Pick<His
  * every requested provenance dimension without consulting mutable state.
  */
 export declare function summarizeAgentProvenance(entries: readonly Pick<HistoryEntry, "agent_harness" | "agent_model" | "agent_provenance">[], dimensions?: readonly string[], minimumExplicitSample?: number): AgentProvenanceDimensionCoverage[];
+/**
+ * Measure role/topic availability by harness and precedence source, then apply
+ * an explicit ratchet. Empty or synthetic corpora therefore remain useful
+ * negative controls instead of silently passing a production coverage gate.
+ */
+export declare function evaluateSemanticAttributionCoverage(entries: readonly Pick<HistoryEntry, "agent_harness" | "agent_provenance">[], options?: {
+    minimumCoverage?: number;
+    minimumEntries?: number;
+}): AgentSemanticAttributionCoverageGate;
 /**
  * Group immutable history by declared episode keys. Legacy entries fall back
  * to their privacy-safe agent instance, or to a deterministic author cohort.

package/dist/sdk/provenance.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]="1f6a4ff8-fc1e-5aac-8117-bae8f325b275")}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]="6162845d-f4b4-5d1f-a210-ddef1a5c38f6")}catch(e){}}();
 import { AGENT_PROVENANCE_DIMENSIONS, BUILTIN_HARNESS_SIGNAL_DESCRIPTORS, } from "../core/shared/author.js";
 /** Resolve the declared or deterministic legacy identity for one history event. */
 export function resolveHistoryEpisodeGroupIdentity(entry) {
@@ -144,6 +144,68 @@ export function summarizeAgentProvenance(entries, dimensions = AGENT_PROVENANCE_
         .sort((left, right) => left.harness.localeCompare(right.harness) ||
         left.dimension.localeCompare(right.dimension));
 }
+/**
+ * Measure role/topic availability by harness and precedence source, then apply
+ * an explicit ratchet. Empty or synthetic corpora therefore remain useful
+ * negative controls instead of silently passing a production coverage gate.
+ */
+export function evaluateSemanticAttributionCoverage(entries, options = {}) {
+    const minimumCoverage = options.minimumCoverage ?? 0.8;
+    const minimumEntries = options.minimumEntries ?? 5;
+    if (![
+        Number.isFinite(minimumCoverage),
+        minimumCoverage >= 0,
+        minimumCoverage <= 1,
+    ].every(Boolean)) {
+        throw new RangeError("Semantic attribution minimum coverage must be from 0 to 1.");
+    }
+    if (![Number.isSafeInteger(minimumEntries), minimumEntries >= 1].every(Boolean)) {
+        throw new RangeError("Semantic attribution minimum entries must be a positive integer.");
+    }
+    const rows = new Map();
+    for (const entry of entries) {
+        if (!entry.agent_harness)
+            continue;
+        for (const dimension of ["role", "topic"]) {
+            const key = `${entry.agent_harness}\0${dimension}`;
+            const row = rows.get(key) ?? {
+                harness: entry.agent_harness,
+                dimension,
+                entries: 0,
+                observed: 0,
+                by_source: {},
+                coverage: 0,
+            };
+            row.entries += 1;
+            const observation = entry.agent_provenance?.[dimension];
+            if (observation?.value) {
+                row.observed += 1;
+                row.by_source[observation.source] =
+                    (row.by_source[observation.source] ?? 0) + 1;
+            }
+            rows.set(key, row);
+        }
+    }
+    const ordered = [...rows.values()]
+        .map((row) => ({
+        ...row,
+        coverage: row.observed / row.entries,
+        by_source: Object.fromEntries(Object.entries(row.by_source).sort(([left], [right]) => left.localeCompare(right))),
+    }))
+        .sort((left, right) => left.harness.localeCompare(right.harness) ||
+        left.dimension.localeCompare(right.dimension));
+    const eligible = ordered.filter((row) => row.entries >= minimumEntries);
+    const failures = eligible
+        .filter((row) => row.coverage < minimumCoverage)
+        .map((row) => `${row.harness}:${row.dimension}`);
+    return {
+        passed: eligible.length > 0 && failures.length === 0,
+        minimum_coverage: minimumCoverage,
+        minimum_entries: minimumEntries,
+        rows: ordered,
+        failures,
+    };
+}
 /**
  * Group immutable history by declared episode keys. Legacy entries fall back
  * to their privacy-safe agent instance, or to a deterministic author cohort.
@@ -194,4 +256,4 @@ export function groupHistoryByEpisode(entries) {
     return roots;
 }
 //# sourceMappingURL=provenance.js.map
-//# debugId=1f6a4ff8-fc1e-5aac-8117-bae8f325b275
+//# debugId=6162845d-f4b4-5d1f-a210-ddef1a5c38f6

package/dist/sdk/query/activity.d.ts

@@ -18,6 +18,8 @@ export interface ActivityCommandOptions {
     limit?: string;
     /** Value that configures or reports compact for this contract. */
     compact?: boolean;
+    /** Return the legacy per-event stream instead of the item-centric digest. */
+    raw?: boolean;
     /** Explicitly disables the default activity bound. */
     unbounded?: boolean;
     /** Return patch-free provenance rows. */
@@ -31,6 +33,10 @@ export interface ActivityCommandOptions {
     /** Exact provenance dimension predicates (`dimension=value`). */
     provenanceFilter?: string | readonly string[];
 }
+/** Normalize raw and full aliases into one explicit activity row projection. */
+export declare function normalizeActivityProjectionOptions(options: ActivityCommandOptions & {
+    full?: unknown;
+}): ActivityCommandOptions;
 /** Documents the activity entry payload exchanged by command, SDK, and package integrations. */
 export interface ActivityEntry extends HistoryEntry {
     /** Stable identifier used to reference this record across commands and storage. */
@@ -49,8 +55,29 @@ export interface CompactActivityEntry {
     /** Value that configures or reports msg for this contract. */
     msg?: string;
 }
+/** One item-centric summary of every matching immutable event for that item. */
+export interface ActivityDigestEntry {
+    /** Stable item identifier. */
+    id: string;
+    /** Current item type from the light metadata join. */
+    type: string;
+    /** Current lifecycle status from the light metadata join. */
+    status: string;
+    /** Current item title, bounded for predictable context cost. */
+    title: string;
+    /** Matching immutable events folded into this row. */
+    event_count: number;
+    /** Oldest matching event timestamp. */
+    first_ts: string;
+    /** Newest matching event timestamp. */
+    last_ts: string;
+    /** Bounded operation histogram encoded as comma-separated op:count pairs. */
+    operations: string;
+}
 /** Documents the activity result payload exchanged by command, SDK, and package integrations. */
 export interface ActivityResult {
+    /** Default item-centric workspace activity rows. */
+    activity_digest?: ActivityDigestEntry[];
     /** Value that configures or reports activity for this contract. */
     activity?: ActivityEntry[];
     /** Value that configures or reports compact activity for this contract. */
@@ -62,9 +89,9 @@ export interface ActivityResult {
     /** Explicit active row projection. */
     projection: {
         /** Stable projection mode. */
-        mode: "compact" | "provenance" | "full";
+        mode: "digest" | "compact" | "provenance" | "full";
         /** Active row collection key. */
-        row_key: "compact_activity" | "provenance_activity" | "activity";
+        row_key: "activity_digest" | "compact_activity" | "provenance_activity" | "activity";
     };
     /** Constant-size disclosure of field groups withheld by the active mode. */
     omission_receipt: OutputOmissionReceipt;
@@ -84,9 +111,25 @@ export interface ActivityResult {
         source: "default" | "explicit";
         value: number | null;
     };
+    /** Constant-size description of the selected time window and matching corpus. */
+    activity_summary?: {
+        window: {
+            from: string | null;
+            to: string | null;
+        };
+        event_count: number;
+        item_count: number;
+        author_count: number;
+        operation_counts: Record<string, number>;
+    };
     /** Constant-size provenance completeness metrics. */
     provenance_summary?: HistoryProvenanceSummary;
 }
+interface ActivityItemMetadata {
+    title: string;
+    type: string;
+    status: string;
+}
 declare function parseNonEmptyFilter(raw: string | undefined, flagLabel: string): string | undefined;
 declare function parseRangeBound(raw: string | undefined, nowValue: string, fieldLabel: string): string | undefined;
 declare function includeByTimeWindow(entry: ActivityEntry, from: string | undefined, to: string | undefined): boolean;
@@ -95,6 +138,8 @@ declare function readActivityString(value: unknown, fallback?: string): string;
 declare function normalizeActivityEntry(id: string, entry: HistoryEntry): ActivityEntry;
 declare function sortActivity(entries: ActivityEntry[]): ActivityEntry[];
 declare function listHistoryFiles(historyDir: string): Promise<string[]>;
+declare function buildActivityDigest(activity: readonly ActivityEntry[], itemsById: ReadonlyMap<string, ActivityItemMetadata>): ActivityDigestEntry[];
+declare function activityOperationCounts(activity: readonly Pick<ActivityEntry, "op">[]): Record<string, number>;
 /** Public contract for test only, shared by SDK and presentation-layer consumers. */
 export declare const _testOnly: {
     parseNonEmptyFilter: typeof parseNonEmptyFilter;
@@ -105,6 +150,8 @@ export declare const _testOnly: {
     normalizeActivityEntry: typeof normalizeActivityEntry;
     sortActivity: typeof sortActivity;
     listHistoryFiles: typeof listHistoryFiles;
+    buildActivityDigest: typeof buildActivityDigest;
+    activityOperationCounts: typeof activityOperationCounts;
 };
 /** Implements run activity for the public runtime surface of this module. */
 export declare function runActivity(options: ActivityCommandOptions, global: GlobalOptions): Promise<ActivityResult>;

package/dist/sdk/query/activity.js

@@ -4,7 +4,7 @@
  * Implements the pm activity command surface and its agent-facing runtime behavior.
  */
 
-!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]="a7efa5e0-5610-51ca-8288-4f5410dbcf51")}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]="27a71d4d-f496-5d0a-9771-caa43b81e1f7")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { getActiveExtensionRegistrations, runActiveOnReadHooks, pathExists, enforceHistoryStreamPolicyForItems, resolveItemTypeRegistry, EXIT_CODE, PmCliError, compareTimestampStrings, nowIso, resolveIsoOrRelative, listAllItemMetadataLight, getSettingsPath, resolvePmRoot, readSettings, } from "../runtime-primitives.js";
@@ -14,6 +14,27 @@ import { resolveModePairedOutputOmissionReceipt, } from "../output-projection.js
 import { compileHistoryProvenanceMatcher, projectHistoryProvenance, resolveHistoryProvenanceDimensions, summarizeHistoryProvenance, } from "../history-provenance.js";
 const DEFAULT_COMPACT_ACTIVITY_LIMIT = 20;
 const DEFAULT_FULL_ACTIVITY_LIMIT = 5;
+const DEFAULT_DIGEST_ACTIVITY_LIMIT = 15;
+const DEFAULT_DIGEST_WINDOW = "-24h";
+/** Normalize raw and full aliases into one explicit activity row projection. */
+export function normalizeActivityProjectionOptions(options) {
+    const normalized = { ...options };
+    if (normalized.full === true) {
+        normalized.raw = true;
+        normalized.compact = false;
+    }
+    else if (normalized.raw === true && normalized.compact === undefined) {
+        normalized.compact = true;
+    }
+    delete normalized.full;
+    return normalized;
+}
+const ACTIVITY_ROW_KEY_BY_MODE = {
+    digest: "activity_digest",
+    compact: "compact_activity",
+    provenance: "provenance_activity",
+    full: "activity",
+};
 function parseNonEmptyFilter(raw, flagLabel) {
     if (raw === undefined)
         return undefined;
@@ -92,10 +113,36 @@ async function listHistoryFiles(historyDir) {
         throw error;
     }
 }
-function resolveActivityFilters(options) {
+function resolveActivityProjectionMode(options) {
+    if (options.raw !== true &&
+        options.compact !== true &&
+        options.provenance !== true) {
+        return "digest";
+    }
+    if (options.provenance === true)
+        return "provenance";
+    if (options.compact === true ||
+        (options.raw === true && options.compact !== false)) {
+        return "compact";
+    }
+    return "full";
+}
+function resolveActivityLimit(options, explicitLimit, projectionMode) {
+    if (options.unbounded === true)
+        return undefined;
+    if (explicitLimit !== undefined)
+        return explicitLimit;
+    if (projectionMode === "digest")
+        return DEFAULT_DIGEST_ACTIVITY_LIMIT;
+    if (projectionMode === "compact")
+        return DEFAULT_COMPACT_ACTIVITY_LIMIT;
+    return DEFAULT_FULL_ACTIVITY_LIMIT;
+}
+function resolveActivityFilters(options, projectionMode) {
     const nowValue = nowIso();
-    const from = parseRangeBound(options.from, nowValue, "--from");
-    const to = parseRangeBound(options.to, nowValue, "--to");
+    const digest = projectionMode === "digest";
+    const to = parseRangeBound(options.to ?? (digest ? nowValue : undefined), nowValue, "--to");
+    const from = parseRangeBound(options.from ?? (digest ? DEFAULT_DIGEST_WINDOW : undefined), options.from === undefined && digest ? to : nowValue, "--from");
     if (from && to && compareTimestampStrings(from, to) >= 0) {
         throw new PmCliError("Activity --from must be before --to", EXIT_CODE.USAGE);
     }
@@ -109,12 +156,7 @@ function resolveActivityFilters(options) {
         author: parseNonEmptyFilter(options.author, "Activity --author"),
         from,
         to,
-        limit: options.unbounded === true
-            ? undefined
-            : (explicitLimit ??
-                (options.compact === true
-                    ? DEFAULT_COMPACT_ACTIVITY_LIMIT
-                    : DEFAULT_FULL_ACTIVITY_LIMIT)),
+        limit: resolveActivityLimit(options, explicitLimit, projectionMode),
         limitSource: options.unbounded === true || explicitLimit !== undefined
             ? "explicit"
             : "default",
@@ -147,7 +189,13 @@ async function prepareActivityHistoryRead(context) {
         path: historyDir,
         scope: "project",
     });
-    return historyDir;
+    return {
+        historyDir,
+        itemsById: new Map(items.map((item) => [
+            item.id,
+            { title: item.title, type: item.type, status: item.status },
+        ])),
+    };
 }
 function includeActivityEntry(entry, candidate, filters) {
     // Preserve legacy filter semantics: op/author filters compare the raw
@@ -186,6 +234,105 @@ function formatCompactActivity(activity) {
         ...(entry.message ? { msg: entry.message } : {}),
     }));
 }
+function boundedOperationSummary(counts) {
+    const ordered = [...counts.entries()].sort(([leftOp, leftCount], [rightOp, rightCount]) => rightCount - leftCount || leftOp.localeCompare(rightOp));
+    const visible = ordered.slice(0, 4).map(([op, count]) => `${op}:${count}`);
+    if (ordered.length > visible.length) {
+        visible.push(`+${ordered.length - visible.length}`);
+    }
+    return visible.join(",");
+}
+function buildActivityDigest(activity, itemsById) {
+    const grouped = new Map();
+    for (const entry of activity) {
+        const current = grouped.get(entry.id);
+        if (current === undefined) {
+            grouped.set(entry.id, {
+                firstTs: entry.ts,
+                lastTs: entry.ts,
+                eventCount: 1,
+                operations: new Map([[entry.op, 1]]),
+            });
+            continue;
+        }
+        current.eventCount += 1;
+        if (compareTimestampStrings(entry.ts, current.firstTs) < 0) {
+            current.firstTs = entry.ts;
+        }
+        if (compareTimestampStrings(entry.ts, current.lastTs) > 0) {
+            current.lastTs = entry.ts;
+        }
+        current.operations.set(entry.op, (current.operations.get(entry.op) ?? 0) + 1);
+    }
+    return [...grouped.entries()]
+        .map(([id, summary]) => {
+        const item = itemsById.get(id);
+        return {
+            id,
+            type: item?.type ?? "unknown",
+            status: item?.status ?? "unknown",
+            title: (item?.title ?? "(item metadata unavailable)").slice(0, 160),
+            event_count: summary.eventCount,
+            first_ts: summary.firstTs,
+            last_ts: summary.lastTs,
+            operations: boundedOperationSummary(summary.operations),
+        };
+    })
+        .sort((left, right) => compareTimestampStrings(right.last_ts, left.last_ts) ||
+        left.id.localeCompare(right.id));
+}
+function activityOperationCounts(activity) {
+    const counts = new Map();
+    for (const entry of activity) {
+        counts.set(entry.op, (counts.get(entry.op) ?? 0) + 1);
+    }
+    const ordered = [...counts.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+    const visible = ordered.slice(0, 8);
+    if (visible.length < ordered.length) {
+        visible.push([
+            `+${String(ordered.length - visible.length)}`,
+            ordered
+                .slice(visible.length)
+                .reduce((total, [, count]) => total + count, 0),
+        ]);
+    }
+    return Object.fromEntries(visible);
+}
+function projectActivityRows(projectionMode, matchingActivity, limit, itemsById, projectProvenance) {
+    if (projectionMode === "digest") {
+        const matchingDigest = buildActivityDigest(matchingActivity, itemsById);
+        const activityDigest = limitEntries(matchingDigest, limit);
+        return {
+            rows: { activity_digest: activityDigest },
+            compact: false,
+            totalRows: matchingDigest.length,
+            returnedRows: activityDigest.length,
+        };
+    }
+    const activity = limitEntries(matchingActivity, limit);
+    if (projectionMode === "compact") {
+        return {
+            rows: { compact_activity: formatCompactActivity(activity) },
+            compact: true,
+            totalRows: matchingActivity.length,
+            returnedRows: activity.length,
+        };
+    }
+    if (projectionMode === "provenance") {
+        return {
+            rows: { provenance_activity: activity.map(projectProvenance) },
+            compact: false,
+            totalRows: matchingActivity.length,
+            returnedRows: activity.length,
+        };
+    }
+    return {
+        rows: { activity },
+        compact: false,
+        totalRows: matchingActivity.length,
+        returnedRows: activity.length,
+    };
+}
 /** Public contract for test only, shared by SDK and presentation-layer consumers. */
 export const _testOnly = {
     parseNonEmptyFilter,
@@ -196,12 +343,15 @@ export const _testOnly = {
     normalizeActivityEntry,
     sortActivity,
     listHistoryFiles,
+    buildActivityDigest,
+    activityOperationCounts,
 };
 /** Implements run activity for the public runtime surface of this module. */
 export async function runActivity(options, global) {
     const context = await resolveActivityRuntimeContext(global);
-    const filters = resolveActivityFilters(options);
-    const historyDir = await prepareActivityHistoryRead(context);
+    const projectionMode = resolveActivityProjectionMode(options);
+    const filters = resolveActivityFilters(options, projectionMode);
+    const prepared = await prepareActivityHistoryRead(context);
     const provenanceDimensions = resolveHistoryProvenanceDimensions(context.settings.agent_identity.harness_signals);
     const vocabulary = context.settings.agent_identity.identity_vocabulary;
     const matchesProvenance = compileHistoryProvenanceMatcher({
@@ -209,37 +359,33 @@ export async function runActivity(options, global) {
         agentInstance: filters.agentInstance,
         provenance: filters.provenance,
     }, vocabulary, provenanceDimensions);
-    const matchingActivity = sortActivity(await collectActivityEntries(historyDir, filters)).filter(matchesProvenance);
-    const activity = limitEntries(matchingActivity, filters.limit);
-    const compact = options.compact === true;
-    const compactActivity = compact ? formatCompactActivity(activity) : undefined;
-    const provenanceActivity = options.provenance === true
-        ? activity.map((entry) => projectHistoryProvenance(entry, vocabulary, { itemId: entry.id }))
-        : undefined;
-    const omittedCount = matchingActivity.length - activity.length;
-    const projectionMode = options.provenance === true ? "provenance" : compact ? "compact" : "full";
-    const rowProjection = {
-        compact: { compact_activity: compactActivity },
-        provenance: { provenance_activity: provenanceActivity },
-        full: { activity },
-    }[projectionMode];
+    const matchingActivity = sortActivity(await collectActivityEntries(prepared.historyDir, filters)).filter(matchesProvenance);
+    const projected = projectActivityRows(projectionMode, matchingActivity, filters.limit, prepared.itemsById, (entry) => projectHistoryProvenance(entry, vocabulary, { itemId: entry.id }));
+    const omittedCount = projected.totalRows - projected.returnedRows;
     return {
-        ...rowProjection,
-        compact,
+        ...projected.rows,
+        compact: projected.compact,
         projection: {
             mode: projectionMode,
-            row_key: projectionMode === "compact"
-                ? "compact_activity"
-                : projectionMode === "provenance"
-                    ? "provenance_activity"
-                    : "activity",
+            row_key: ACTIVITY_ROW_KEY_BY_MODE[projectionMode],
         },
         omission_receipt: resolveModePairedOutputOmissionReceipt("activity", projectionMode),
-        count: activity.length,
-        total_count: matchingActivity.length,
+        count: projected.returnedRows,
+        total_count: projected.totalRows,
         limit: filters.limit ?? null,
         omitted_count: omittedCount,
         has_more: omittedCount > 0,
+        ...(projectionMode === "digest"
+            ? {
+                activity_summary: {
+                    window: { from: filters.from, to: filters.to },
+                    event_count: matchingActivity.length,
+                    item_count: projected.totalRows,
+                    author_count: new Set(matchingActivity.map((entry) => entry.author)).size,
+                    operation_counts: activityOperationCounts(matchingActivity),
+                },
+            }
+            : {}),
         ...(options.provenanceSummary === true
             ? {
                 provenance_summary: summarizeHistoryProvenance(matchingActivity, vocabulary, provenanceDimensions),
@@ -253,4 +399,4 @@ export async function runActivity(options, global) {
     };
 }
 //# sourceMappingURL=activity.js.map
-//# debugId=a7efa5e0-5610-51ca-8288-4f5410dbcf51
+//# debugId=27a71d4d-f496-5d0a-9771-caa43b81e1f7

package/dist/sdk/query/context.js

@@ -4,7 +4,7 @@
  * Implements the pm context command surface and its agent-facing runtime behavior.
  */
 
-!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]="161507f0-b1a7-59a6-9a60-d8f09806ed3f")}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]="757a0349-9fb6-579d-ab29-fabaad790ce4")}catch(e){}}();
 import { SETTINGS_DEFAULTS, EXIT_CODE, PmCliError, compareTimestampStrings, nowIso, isTerminalStatus, normalizeStatusForRegistry, normalizeStatusInput, resolveRuntimeStatusRegistry, resolvePmRoot, readSettings, resolveAuthor, discoverExtensions, } from "../runtime-primitives.js";
 import { collectDependencyBlockedIds, resolveItemBlockers, } from "../actionability.js";
 import { CONTEXT_DEPTH_VALUES, CONTEXT_SECTION_VALUES, } from "../../types/index.js";
@@ -20,6 +20,9 @@ import { packContextCandidates, } from "../context-packing.js";
 import { readContextUsageAffinity, recordContextUsageServing, } from "../context-usage.js";
 import { readWorkspaceContextSignals, } from "../context-signal-store.js";
 import { readWorkspaceMemory, selectWorkspaceMemory, } from "../workspace-memory.js";
+import { detectAgentIdentity } from "../../core/shared/author.js";
+import { readSessionState, semanticAttributionKey, } from "../../core/session/session-state.js";
+import { semanticAttributionAffinity } from "../context/semantic-session-attribution.js";
 // ---------------------------------------------------------------------------
 // Output format
 // ---------------------------------------------------------------------------
@@ -1223,7 +1226,7 @@ function resolveContextSubtreeIds(parentScope, fullCorpus) {
     }
     return subtree.ids;
 }
-async function resolveContextFocusGroups(listedItemMetadata, allItems, fullCorpus, blockedIds, statusRegistry, sectionsIncluded, limit, now, author, cursor, cursorFingerprint, useBoundedPage, pmRoot, tokenBudget) {
+async function resolveContextFocusGroups(listedItemMetadata, allItems, fullCorpus, blockedIds, statusRegistry, sectionsIncluded, limit, now, author, cursor, cursorFingerprint, useBoundedPage, pmRoot, tokenBudget, claimFocus) {
     const structural = [...listedItemMetadata].sort((left, right) => compareCriticalItems(left, right, statusRegistry));
     const usage = await readContextUsageAffinity({
         pmRoot,
@@ -1237,6 +1240,7 @@ async function resolveContextFocusGroups(listedItemMetadata, allItems, fullCorpu
         now,
         author,
         usageAffinity: usage.affinity,
+        claimFocus,
     });
     const ranking = await scoreContextCandidatesWithActiveExtensions("context", featureStore.candidates);
     const ranked = ranking.ranked.map((entry) => entry.item);
@@ -1262,7 +1266,9 @@ async function resolveContextFocusGroups(listedItemMetadata, allItems, fullCorpu
     const packing = packRankedContextItems({
         ...ranking,
         ranked: ranking.ranked.filter((entry) => packingIds.has(entry.id)),
-    }, tokenBudget);
+    }, tokenBudget, new Set(Object.entries(claimFocus ?? {})
+        .filter(([, affinity]) => affinity >= 1)
+        .map(([id]) => id)));
     const packedItems = packing.included.map((entry) => entry.item);
     const activeItems = packedItems.filter((item) => activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
     const blockedItems = packedItems.filter((item) => blockedIds.has(item.id.trim().toLowerCase()));
@@ -1297,9 +1303,7 @@ async function resolveContextFocusGroups(listedItemMetadata, allItems, fullCorpu
         highLevel,
         lowLevel,
         blockedFallback: blockedFallbackUsed
-            ? blockedItems
-                .slice(0, limit)
-                .map(projectFocusItem)
+            ? blockedItems.slice(0, limit).map(projectFocusItem)
             : [],
         blockedFallbackUsed,
         ranking,
@@ -1554,6 +1558,12 @@ export async function resolveContextExtensionHealthProjection(omitted, pmRoot, s
         },
     };
 }
+async function resolveContextSemanticAffinity(pmRoot, author) {
+    const identity = detectAgentIdentity();
+    const semanticState = await readSessionState(pmRoot);
+    const attributionKey = identity.instance || semanticAttributionKey(author);
+    return semanticAttributionAffinity(semanticState.semantic_attribution?.[attributionKey]);
+}
 /** Implements run context for the public runtime surface of this module. */
 export async function runContext(options, global) {
     const pmRoot = resolvePmRoot(process.cwd(), global.path);
@@ -1566,11 +1576,12 @@ export async function runContext(options, global) {
         tokenBudget: resolveContextTokenBudget(options.tokenBudget, Math.max(256, scaledLimit * 160)),
     };
     const author = resolveAuthor(undefined, runtime.settings.author_default);
+    const claimFocus = await resolveContextSemanticAffinity(pmRoot, author);
     const extensionHealthPromise = resolveContextExtensionHealthProjection(options.noExtensionHealth === true, pmRoot, runtime.settings);
     // Single shared edge-aware blocked classification (GH-578): resolved against
     // the full corpus so terminal blocker targets count as satisfied at every depth.
     const blockedIds = collectDependencyBlockedIds(corpus.fullCorpus, runtime.statusRegistry);
-    const focusGroups = await resolveContextFocusGroups(corpus.listedItemMetadata, corpus.allItems, corpus.fullCorpus, blockedIds, runtime.statusRegistry, runtime.sectionsIncluded, runtime.limit, nowIso(), author, options.after, buildContextCursorFingerprint(options), shouldPageContextFocus(options, corpus.fullCorpus.length), pmRoot, runtime.tokenBudget);
+    const focusGroups = await resolveContextFocusGroups(corpus.listedItemMetadata, corpus.allItems, corpus.fullCorpus, blockedIds, runtime.statusRegistry, runtime.sectionsIncluded, runtime.limit, nowIso(), author, options.after, buildContextCursorFingerprint(options), shouldPageContextFocus(options, corpus.fullCorpus.length), pmRoot, runtime.tokenBudget, claimFocus);
     const agendaContext = await buildContextAgenda(global, runtime, corpus.subtreeIds, new Set([
         ...focusGroups.highLevel,
         ...focusGroups.lowLevel,
@@ -1659,4 +1670,4 @@ export async function runContext(options, global) {
     return result;
 }
 //# sourceMappingURL=context.js.map
-//# debugId=161507f0-b1a7-59a6-9a60-d8f09806ed3f
+//# debugId=757a0349-9fb6-579d-ab29-fabaad790ce4