@event4u/agent-config 8.6.0 → 8.8.0

package/src/scripts/mcp_server/consumer_tool_catalog.json

@@ -50,14 +50,18 @@
           "last": {"type": "integer", "description": "Return only the most recent N entries, after other filters apply.", "minimum": 1},
           "session": {"type": "string", "description": "Filter to a single 16-char session id."},
           "entry_type": {"type": "string", "description": "Filter by the `t` tag (e.g. note, decision, phase)."},
-          "path": {"type": "string", "description": "Optional history-file path override; defaults to the standard chat-history location under the project root."}
+          "path": {"type": "string", "description": "Optional history-file path override; defaults to the standard chat-history location under the project root."},
+          "around": {"type": "integer", "minimum": 0, "description": "Timeline anchor: return the entries around this ref (from a detail:\"index\" row) instead of the filtered list — depth_before/depth_after neighbours plus the anchor. Refs are within-file ordinals; rotation invalidates them."},
+          "depth_before": {"type": "integer", "minimum": 0, "default": 3, "description": "Neighbours before the anchor (with `around`). Defaults to 3."},
+          "depth_after": {"type": "integer", "minimum": 0, "default": 3, "description": "Neighbours after the anchor (with `around`). Defaults to 3."},
+          "detail": {"type": "string", "enum": ["index", "full"], "default": "full", "description": "'index' returns compact rows (ref, t tag, ~100-char preview, tokens_estimate) instead of full entries — scan first, then re-read the refs you need via `around` or a narrowed filter. 'full' (default) returns complete entries."}
         },
         "additionalProperties": false
       }
     },
     {
       "name": "memory_lookup",
-      "description": "Retrieve engineering-memory entries for one or more memory types, optionally narrowed to specific anchor paths. Use before editing a security-sensitive or historically buggy file to surface prior incidents, ownership, and patterns tied to it. Reads `agents/memory/<type>/*.yml` plus the `agents/memory/intake/*.jsonl` signal log. Read-only. Returns the v1 retrieval envelope: a `status` field plus per-type `slices` carrying the matched entries.",
+      "description": "Retrieve engineering-memory entries for one or more memory types, optionally narrowed to specific anchor paths. Use before editing a security-sensitive or historically buggy file to surface prior incidents, ownership, and patterns tied to it. WORKFLOW: call with detail:\"index\" FIRST — each row carries id, title and tokens_estimate (the cost of fetching it) — then fetch full bodies via memory_get ONLY for the ids you will actually use, batching multiple ids into one call. Reads `agents/memory/<type>/*.yml` plus the `agents/memory/intake/*.jsonl` signal log. Read-only. Returns the v1 retrieval envelope: a `status` field plus per-type `slices` carrying the matched entries.",
       "side_effect": "ro",
       "implemented_on": ["stdio"],
       "input_schema": {
@@ -65,12 +69,27 @@
         "properties": {
           "types": {"type": "array", "items": {"type": "string"}, "minItems": 1, "description": "Memory types to scan, e.g. `historical-patterns`, `incident-learnings`, `ownership`. At least one required."},
           "keys": {"type": "array", "items": {"type": "string"}, "description": "Optional anchor paths or globs to match entries against (e.g. a file you are about to edit)."},
-          "limit": {"type": "integer", "minimum": 1, "default": 5, "description": "Maximum entries to return per type. Defaults to 5."}
+          "limit": {"type": "integer", "minimum": 1, "default": 5, "description": "Maximum entries to return per type. Defaults to 5."},
+          "detail": {"type": "string", "enum": ["index", "full"], "default": "full", "description": "'index' returns compact priced rows (id, title, tokens_estimate) instead of full bodies — call this first, then memory_get the ids you need. 'full' (default) returns complete entries."}
         },
         "required": ["types"],
         "additionalProperties": false
       }
     },
+    {
+      "name": "memory_get",
+      "description": "Batch-fetch FULL memory entries by id — the second half of the index-first retrieval workflow. Call memory_lookup with detail:\"index\" first, pick the ids whose title/tokens_estimate justify the fetch, then fetch them here in ONE batched call. Unknown ids are reported per-id (ids[<id>]=\"unknown\"), never failing the batch. Read-only.",
+      "side_effect": "ro",
+      "implemented_on": ["stdio"],
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "ids": {"type": "array", "items": {"type": "string"}, "minItems": 1, "description": "Entry ids to fetch (from a detail:\"index\" lookup)."}
+        },
+        "required": ["ids"],
+        "additionalProperties": false
+      }
+    },
     {
       "name": "memory_signal",
       "description": "Record an engineering-memory signal — a short, anchored observation such as a recurring bug pattern or an ownership note — to the monthly intake log `agents/memory/intake/signals-YYYY-MM.jsonl`. Use to capture a learning tied to a specific file so future `memory_lookup` calls surface it. Appends to the filesystem and is rate-limited per `(type, path)` within a rolling window. Returns the recorded signal.",

package/src/scripts/mcp_server/tools.ts

@@ -38,7 +38,10 @@ import {
     SCHEMA_VERSION as _CH_SCHEMA_VERSION,
     append as _chAppendImpl,
     init as _chInitImpl,
+    history_index_row as _chHistoryIndexRow,
     read_entries as _chReadEntriesImpl,
+    read_entries_with_refs as _chReadEntriesWithRefs,
+    slice_around as _chSliceAround,
     read_header as _chReadHeaderImpl,
 } from '../chat_history.js';
 import {
@@ -364,10 +367,63 @@ async function _chatHistoryReadHandler(
         throw new Error("'entry_type' must be a string when provided");
     }
 
+    const around = args.around;
+    if (
+        around !== undefined &&
+        around !== null &&
+        (typeof around !== 'number' || !Number.isInteger(around) || around < 0)
+    ) {
+        throw new Error("'around' must be a non-negative integer when provided");
+    }
+    const depthBefore = args.depth_before ?? 3;
+    const depthAfter = args.depth_after ?? 3;
+    for (const [name, v] of [
+        ['depth_before', depthBefore],
+        ['depth_after', depthAfter],
+    ] as const) {
+        if (typeof v !== 'number' || !Number.isInteger(v) || v < 0) {
+            throw new Error(`'${name}' must be a non-negative integer`);
+        }
+    }
+    const detail = args.detail ?? 'full';
+    if (detail !== 'full' && detail !== 'index') {
+        throw new Error("'detail' must be 'index' or 'full'");
+    }
+
     if (!fs.existsSync(target)) {
         return { path: target, entries: [], count: 0 };
     }
 
+    // Timeline anchor path (road-to-memory-retrieval-economy Phase 3):
+    // refs index the FULL chronological list, so `around` ignores the
+    // session/entry_type/last filters by contract.
+    if (around !== undefined && around !== null) {
+        const pairs = _chSliceAround(
+            target,
+            around as number,
+            depthBefore as number,
+            depthAfter as number,
+        );
+        const entries =
+            detail === 'index'
+                ? pairs.map((p) => _chHistoryIndexRow(p))
+                : pairs.map((p) => ({ ref: p.ref, ...p.entry }));
+        return { path: target, entries, count: entries.length, anchor: around };
+    }
+
+    if (detail === 'index') {
+        let pairs = _chReadEntriesWithRefs({
+            path: target,
+            last: (last ?? null) as number | null,
+            session: (session ?? null) as string | null,
+        });
+        if (entryType) {
+            pairs = pairs.filter((p) => p.entry.t === entryType);
+        }
+        const entries = pairs.map((p) => _chHistoryIndexRow(p));
+        return { path: target, entries, count: entries.length };
+    }
+
     let entries = _chReadEntries(
         target,
         (last ?? null) as number | null,
@@ -416,6 +472,11 @@ async function _memoryLookupHandler(
     // Mirror the Python `os.chdir(consumer_root)` scoping: memory_lookup
     // resolves `agents/memory` relative to CWD, so the consumer root is
     // applied via a chdir window that is always restored.
+    const detailRaw = args.detail ?? 'full';
+    if (detailRaw !== 'full' && detailRaw !== 'index') {
+        throw new Error("'detail' must be 'index' or 'full'");
+    }
+
     const prevCwd = process.cwd();
     let envelope: Record<string, unknown>;
     try {
@@ -424,6 +485,7 @@ async function _memoryLookupHandler(
             [...(types as string[])],
             [...(keys as string[])],
             limitRaw,
+            { detail: detailRaw },
         );
     } finally {
         process.chdir(prevCwd);
@@ -431,6 +493,30 @@ async function _memoryLookupHandler(
     return envelope;
 }
 
+/**
+ * Batch full-entry fetch by ID (road-to-memory-retrieval-economy Phase 1).
+ * The second half of the index→fetch economy: `memory_lookup` with
+ * `detail: 'index'` returns priced rows; this fetches ONLY the bodies the
+ * caller actually needs. Unknown IDs degrade per-ID, never the batch.
+ */
+async function _memoryGetHandler(
+    args: Record<string, unknown>,
+    consumerRoot: string,
+): Promise<Record<string, unknown>> {
+    const memoryLookup = await import('../memory_lookup.js');
+    const ids = args.ids;
+    if (!Array.isArray(ids) || ids.length === 0 || !ids.every((i) => typeof i === 'string')) {
+        throw new Error("'ids' must be a non-empty list of strings");
+    }
+    const prevCwd = process.cwd();
+    try {
+        process.chdir(consumerRoot);
+        return memoryLookup.memory_get_v1([...(ids as string[])]);
+    } finally {
+        process.chdir(prevCwd);
+    }
+}
+
 /** Phase 3 L2 — surface `scripts/memory_status.status()` as JSON. */
 async function _memoryStatusHandler(
     _args: Record<string, unknown>,
@@ -1225,6 +1311,40 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
                         'the standard chat-history location under the ' +
                         'project root.',
                 },
+                around: {
+                    type: 'integer',
+                    minimum: 0,
+                    description:
+                        'Timeline anchor: return the entries around this ' +
+                        'ref (from a detail:"index" row) instead of the ' +
+                        'filtered list — depth_before/depth_after ' +
+                        'neighbours plus the anchor. Refs are within-file ' +
+                        'ordinals; rotation invalidates them.',
+                },
+                depth_before: {
+                    type: 'integer',
+                    minimum: 0,
+                    default: 3,
+                    description: 'Neighbours before the anchor (with `around`). Defaults to 3.',
+                },
+                depth_after: {
+                    type: 'integer',
+                    minimum: 0,
+                    default: 3,
+                    description: 'Neighbours after the anchor (with `around`). Defaults to 3.',
+                },
+                detail: {
+                    type: 'string',
+                    enum: ['index', 'full'],
+                    default: 'full',
+                    description:
+                        "'index' returns compact rows (ref, t tag, ~100-char " +
+                        'preview, tokens_estimate) instead of full entries — ' +
+                        'scan first, then re-read the refs you need via ' +
+                        '`around` or a narrowed filter. History entries are ' +
+                        "large, so index mode pays off here. 'full' " +
+                        '(default) returns complete entries.',
+                },
             },
             additionalProperties: false,
         },
@@ -1237,7 +1357,11 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
             'types, optionally narrowed to specific anchor paths. Use ' +
             'before editing a security-sensitive or historically buggy ' +
             'file to surface prior incidents, ownership, and patterns ' +
-            'tied to it. Reads `agents/memory/<type>/*.yml` plus the ' +
+            'tied to it. WORKFLOW: call with detail:"index" FIRST — each ' +
+            'row carries id, title and tokens_estimate (the cost of ' +
+            'fetching it) — then fetch full bodies via memory_get ONLY ' +
+            'for the ids you will actually use, batching multiple ids ' +
+            'into one call. Reads `agents/memory/<type>/*.yml` plus the ' +
             '`agents/memory/intake/*.jsonl` signal log. Read-only. ' +
             'Returns the v1 retrieval envelope: a `status` field plus ' +
             'per-type `slices` carrying the matched entries.',
@@ -1266,12 +1390,46 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
                     default: 5,
                     description: 'Maximum entries to return per type. Defaults to 5.',
                 },
+                detail: {
+                    type: 'string',
+                    enum: ['index', 'full'],
+                    default: 'full',
+                    description:
+                        "'index' returns compact priced rows (id, title, " +
+                        "tokens_estimate) instead of full bodies — call " +
+                        "this first, then memory_get the ids you need. " +
+                        "'full' (default) returns complete entries.",
+                },
             },
             required: ['types'],
             additionalProperties: false,
         },
         handler: _memoryLookupHandler,
     },
+    memory_get: {
+        name: 'memory_get',
+        description:
+            'Batch-fetch FULL memory entries by id — the second half of ' +
+            'the index-first retrieval workflow. Call memory_lookup with ' +
+            'detail:"index" first, pick the ids whose title/tokens_estimate ' +
+            'justify the fetch, then fetch them here in ONE batched call. ' +
+            'Unknown ids are reported per-id (ids[<id>]="unknown"), never ' +
+            'failing the batch. Read-only.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    minItems: 1,
+                    description: 'Entry ids to fetch (from a detail:"index" lookup).',
+                },
+            },
+            required: ['ids'],
+            additionalProperties: false,
+        },
+        handler: _memoryGetHandler,
+    },
     memory_status: {
         name: 'memory_status',
         description:

package/src/scripts/memory_lookup.ts

@@ -32,6 +32,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
 import YAML, { parseDocument } from 'yaml';
 
 
@@ -578,6 +579,77 @@ function _isStale(entry: Record<string, unknown>, today: Date): boolean {
  * active, non-stale entries flow through `_iter_curated_entries` in the
  * normal path.
  */
+/**
+ * Deterministic entry ID (road-to-memory-retrieval-economy Phase 1).
+ *
+ * Precedence: the entry's own `id` field when present and non-empty;
+ * otherwise `<type>:<file-basename>:<ordinal>` where `ordinal` is the
+ * entry's 0-based position within its source file (iteration order is
+ * sorted and therefore stable across re-runs on an unchanged tree).
+ * `memory_get_v1` derives ids with the SAME function, so lookup and batch
+ * fetch can never disagree.
+ */
+export function _entry_id(
+    mtype: string,
+    file: string,
+    entry: Record<string, unknown>,
+    ordinals: Map<string, number>,
+): string {
+    const ordinal = ordinals.get(file) ?? 0;
+    ordinals.set(file, ordinal + 1);
+    const own = entry['id'];
+    if (typeof own === 'string' && own.trim() !== '') {
+        return own;
+    }
+    if (own !== undefined && own !== null && String(own).trim() !== '') {
+        return String(own);
+    }
+    return `${mtype}:${path.basename(file)}:${ordinal}`;
+}
+
+/** Human-scannable title for an index row: title > key > path > first body line > id. */
+export function _entry_title(entry: Record<string, unknown>, id: string): string {
+    for (const field of ['title', 'key', 'path']) {
+        const v = entry[field];
+        if (typeof v === 'string' && v.trim() !== '') {
+            return v.trim().slice(0, 120);
+        }
+    }
+    const body = entry['body'];
+    if (typeof body === 'string' && body.trim() !== '') {
+        const first = body.trim().split('\n')[0] as string;
+        return first.trim().slice(0, 120);
+    }
+    return id;
+}
+
+// Lazy tokenizer handle — the index mode is the ONLY consumer; the default
+// full path must not pay the tiktoken load (hot MCP import path).
+let _tokenizer: { gpt_tokens: (t: string) => { tokens: number }; TIKTOKEN_AVAILABLE: boolean } | null | undefined;
+function _lazy_tokenizer(): typeof _tokenizer {
+    if (_tokenizer === undefined) {
+        try {
+            const req = createRequire(import.meta.url);
+            _tokenizer = req('./_lib/token_count.js');
+        } catch {
+            _tokenizer = null;
+        }
+    }
+    return _tokenizer;
+}
+
+/** Real-tokenizer estimate of what fetching this entry's full envelope row costs. */
+export function _entry_tokens_estimate(envelope_entry: Record<string, unknown>): number {
+    const serialized = JSON.stringify(envelope_entry);
+    const tok = _lazy_tokenizer();
+    if (tok !== null && tok !== undefined && tok.TIKTOKEN_AVAILABLE) {
+        return tok.gpt_tokens(serialized).tokens;
+    }
+    // Proxy fallback — a UI hint only; measurements go through the replay
+    // rig which records tokenizer provenance (D2).
+    return Math.ceil(serialized.length / 4);
+}
+
 function _retrieve_internal(types: string[], keys: string[], limit: number, today: Date): [Hit[], SkippedEntry[]] {
     const repo_hits: Hit[] = [];
     const skipped: SkippedEntry[] = [];
@@ -616,20 +688,24 @@ function _retrieve_internal(types: string[], keys: string[], limit: number, toda
         }
         // Curated entries: status filtering happens inside _iter_curated_entries.
         // We additionally filter stale entries here and track them in skipped.
+        const _cur_ordinals = new Map<string, number>();
         for (const [p, entry] of _iter_curated_entries(mtype)) {
-            void p;
+            // ID derivation runs for EVERY yielded entry (before any
+            // filtering) so ordinals stay consistent across all consumers
+            // of the same iterator (retrieve vs memory_get_v1).
+            const eid = _entry_id(mtype, String(p), entry, _cur_ordinals);
             if (_isStale(entry, today)) {
                 const lv = 'last_validated' in entry ? _pyStrDateLike(entry['last_validated']) : 'unknown';
                 const rad = 'review_after_days' in entry ? _pyStr(entry['review_after_days']) : '?';
                 skipped.push({
-                    id: String(entry['id'] ?? ''),
+                    id: eid,
                     type: mtype,
                     reason: 'stale',
                     details: `last_validated=${lv}, review_after_days=${rad}`,
                 });
                 continue;
             }
-            repo_hits.push(new Hit(String(entry['id'] ?? ''), mtype, 'curated', String(p), _score(entry, keys), entry));
+            repo_hits.push(new Hit(eid, mtype, 'curated', String(p), _score(entry, keys), entry));
         }
         // Capture superseded/deprecated entries in skipped (for retrieve_with_meta).
         for (const [p, entry] of _iter_curated_entries_all(mtype)) {
@@ -762,7 +838,19 @@ const _KNOWN_TYPES: ReadonlySet<string> = new Set([...CURATED_TYPES, KNOWLEDGE_T
  * types are reported as `status: unknown_type` for that slice only, rather
  * than failing the whole call. All entries are file-backed (`source: "repo"`).
  */
-export function retrieve_v1(types: string[], keys: string[], limit = 20): Record<string, unknown> {
+export function retrieve_v1(
+    types: string[],
+    keys: string[],
+    limit = 20,
+    options: { detail?: 'index' | 'full' } = {},
+): Record<string, unknown> {
+    // ADDITIVE detail parameter (road-to-memory-retrieval-economy Phase 1,
+    // D1): default 'full' keeps the published v1 envelope byte-identical.
+    // 'index' replaces each entry's `body` with a compact row —
+    // `title` + `tokens_estimate` (the cost `memory_get` would incur) — so
+    // a host can rank before fetching. The default flip to 'index' is a
+    // separate, falsification-gated human decision (Phase 1b).
+    const detail = options.detail ?? 'full';
     const known = types.filter((t) => _KNOWN_TYPES.has(t));
     const unknown = types.filter((t) => !_KNOWN_TYPES.has(t));
 
@@ -785,7 +873,22 @@ export function retrieve_v1(types: string[], keys: string[], limit = 20): Record
         if (h.type in slice_counts) {
             slice_counts[h.type] = (slice_counts[h.type] as number) + 1;
         }
-        entries.push(envelope_entry);
+        if (detail === 'index') {
+            entries.push({
+                id: h.id,
+                type: h.type,
+                source: 'repo',
+                confidence: new PyFloat(_round4(h.score)),
+                title: _entry_title(h.entry, h.id),
+                tokens_estimate: _entry_tokens_estimate(envelope_entry),
+                // Knowledge chunks carry their pinned flag in the index row
+                // (roadmap Phase 4) — pinned entries rank higher, so the
+                // caller should see why before fetching.
+                ...(h.type === KNOWLEDGE_TYPE ? { pinned: Boolean(h.entry['pinned'] ?? false) } : {}),
+            });
+        } else {
+            entries.push(envelope_entry);
+        }
     }
 
     const slices: Record<string, Record<string, unknown>> = {};
@@ -819,6 +922,73 @@ export function retrieve_v1(types: string[], keys: string[], limit = 20): Record
     return envelope;
 }
 
+/**
+ * Batch full-entry fetch by ID — the second half of the two-phase retrieval
+ * economy (road-to-memory-retrieval-economy Phase 1). Scans the same
+ * iterators as {@link retrieve} with the same ID derivation
+ * ({@link _entry_id}), so an ID returned by `detail: 'index'` always
+ * resolves here. Unknown IDs are reported per-ID (`ids[<id>] = 'unknown'`)
+ * rather than failing the batch — matching batch-fetch semantics.
+ *
+ * Envelope: `{contract_version, status, entries, ids}` where `entries`
+ * carry FULL bodies (shape identical to `retrieve_v1` full entries minus
+ * `confidence` — an explicit fetch has no relevance score) and `status` is
+ * `ok` (all found) / `partial` (some) / `error` (none).
+ */
+export function memory_get_v1(ids: string[]): Record<string, unknown> {
+    const wanted = new Set(ids);
+    const found = new Map<string, Record<string, unknown>>();
+
+    const record = (id: string, mtype: string, entry: Record<string, unknown>): void => {
+        if (wanted.has(id) && !found.has(id)) {
+            found.set(id, {
+                id,
+                type: mtype,
+                source: 'repo',
+                body: _isPlainObject(entry) ? { ...entry } : {},
+            });
+        }
+    };
+
+    for (const mtype of CURATED_TYPES) {
+        const ordinals = new Map<string, number>();
+        for (const [p, entry] of _iter_curated_entries(mtype)) {
+            record(_entry_id(mtype, String(p), entry, ordinals), mtype, entry);
+        }
+        for (const [p, entry] of _iter_intake_entries(mtype)) {
+            void p;
+            const own = entry['id'];
+            if (typeof own === 'string' && own.trim() !== '') {
+                record(own, mtype, entry);
+            }
+        }
+    }
+    for (const [p, entry] of _iter_knowledge_entries()) {
+        void p;
+        record(String(entry['id'] ?? ''), KNOWLEDGE_TYPE, entry);
+    }
+
+    const entries: Record<string, unknown>[] = [];
+    const idStatus: Record<string, string> = {};
+    for (const id of ids) {
+        const e = found.get(id);
+        if (e !== undefined) {
+            entries.push(e);
+            idStatus[id] = 'ok';
+        } else {
+            idStatus[id] = 'unknown';
+        }
+    }
+    const okCount = entries.length;
+    const status = okCount === ids.length ? 'ok' : okCount === 0 ? 'error' : 'partial';
+    return {
+        contract_version: _CONTRACT_VERSION,
+        status,
+        entries,
+        ids: idStatus,
+    };
+}
+
 // ---------------------------------------------------------------------------
 // CLI
 // ---------------------------------------------------------------------------
@@ -829,6 +999,7 @@ interface ParsedArgs {
     limit: number;
     format: 'text' | 'json';
     envelope: 'legacy' | 'v1';
+    detail: 'index' | 'full';
 }
 
 function _parseArgs(argv: string[]): ParsedArgs {
@@ -838,6 +1009,7 @@ function _parseArgs(argv: string[]): ParsedArgs {
         limit: 5,
         format: 'text',
         envelope: 'legacy',
+        detail: 'full',
     };
     for (let i = 0; i < argv.length; i += 1) {
         const a = argv[i] as string;
@@ -863,6 +1035,12 @@ function _parseArgs(argv: string[]): ParsedArgs {
             args.envelope = _checkChoice(a.slice('--envelope='.length), ['legacy', 'v1'], '--envelope') as
                 | 'legacy'
                 | 'v1';
+        } else if (a === '--detail') {
+            args.detail = _checkChoice(argv[++i], ['index', 'full'], '--detail') as 'index' | 'full';
+        } else if (a.startsWith('--detail=')) {
+            args.detail = _checkChoice(a.slice('--detail='.length), ['index', 'full'], '--detail') as
+                | 'index'
+                | 'full';
         } else if (a === '-h' || a === '--help') {
             _printUsage();
             process.exit(0);
@@ -915,7 +1093,7 @@ export function main(): number {
         return 2;
     }
     if (args.envelope === 'v1') {
-        const envelope = retrieve_v1(types, args.key, args.limit);
+        const envelope = retrieve_v1(types, args.key, args.limit, { detail: args.detail });
         process.stdout.write(`${pyJsonDumps(envelope, 2)}\n`);
         return 0;
     }