hafez 2.1.0 → 2.3.0

package/dist/index.js

@@ -1,8 +1,9 @@
 // src/index.ts
-import { parseFilePath, slugify, kindFromPath, kindDir, isIndexedRelPath, findVaultFile, vaultFileExists, resolveFilePath, scanVaultDir, INDEXED_KINDS } from './vault.js';
+import { parseFilePath, slugify, kindFromPath, kindDir, isMutableRelPath, findVaultFile, findReadableFile, vaultFileExists, resolveFilePath, scanVaultDir, archiveLogPath, noteAtRelPath, MUTABLE_KINDS } from './vault.js';
 import { createGitJournal } from './git.js';
 import { validateSessionLogEntry } from './schema.js';
 import { validateVault } from './validate.js';
+import { healthReport } from './health.js';
 import { documentForFile } from './document.js';
 import { createIndex } from './db.js';
 import { closestSlugs } from './closest.js';
@@ -14,7 +15,9 @@ import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
 import { join, basename } from 'path';
 import { lock as lockVault } from 'proper-lockfile';
 export function createHafez(config) {
-    const { vaultPath, readOnly = false, git: gitConfig = {}, onWrite } = config;
+    const { vaultPath, readOnly = false, git: gitConfig = {}, onWrite, indexSync = 'read' } = config;
+    // When reads catch the index up with the files (src/internal.ts, off the
+    // public types): 'once' is the CLI's (#269), 'manual' the graph server's (#271).
     // The persistence seam (CONTEXT.md: Journal). Everything below talks to
     // history through this port; git is just the default adapter.
     const journal = config.persistence ?? createGitJournal(vaultPath, gitConfig);
@@ -52,6 +55,7 @@ export function createHafez(config) {
         }
     }
     // Layout answers where a slug lives; these bind the vault path once.
+    // Mutations resolve the mutable kinds; `read` reaches a session note too.
     function findFile(slug) { return findVaultFile(vaultPath, slug); }
     function exists(slug) { return vaultFileExists(vaultPath, slug); }
     function regenerateIndexSafe() {
@@ -65,8 +69,12 @@ export function createHafez(config) {
             // outside hafez — a hand edit, a git pull — are represented too; that
             // costs a stat per file, where the old path paid a parse per file on
             // every single mutation.
+            // Under 'once' the process's first read already caught up.
             const idx = getIndex();
-            idx?.syncIfStale();
+            if (indexSync === 'once')
+                idx?.syncForRead();
+            else
+                idx?.syncIfStale();
             generateVaultIndex(vaultPath, idx?.indexEntries());
         }
         catch (err) {
@@ -77,7 +85,7 @@ export function createHafez(config) {
     let _indexInitialized = false;
     function getIndex() {
         if (!_indexInitialized) {
-            _index = readOnly ? createIndex(vaultPath, { readonly: true }) : createIndex(vaultPath);
+            _index = readOnly ? createIndex(vaultPath, { readonly: true, sync: indexSync }) : createIndex(vaultPath, { sync: indexSync });
             // A null read-only open means the on-disk index is missing or from another
             // schema version. Don't latch it: retry on the next call so a long-lived
             // read-only instance starts serving once a write-capable process rebuilds.
@@ -92,17 +100,14 @@ export function createHafez(config) {
         return idx ? fn(idx) : empty;
     }
     async function read(slug, depth = 'summary') {
-        const filePath = findFile(slug);
+        const filePath = findReadableFile(vaultPath, slug);
         if (!filePath) {
             // A miss carries the closest slugs as its details: the recovery the
             // `read` miss output renders (#91).
-            const closest = withIndex(idx => { idx.syncIfStale(); return closestSlugs(slug, idx.indexEntries()); }, []);
+            const closest = withIndex(idx => { idx.syncForRead(); return closestSlugs(slug, idx.indexEntries()); }, []);
             throw new HafezError('NOT_FOUND', `Entity or knowledge '${slug}' not found`, closest);
         }
         const parsed = parseFilePath(filePath);
-        // findFile only resolves the indexed kinds, so the session arm is unreachable
-        if (parsed.kind === 'session')
-            throw new HafezError('NOT_FOUND', `Entity or knowledge '${slug}' not found`);
         if (depth === 'frontmatter')
             return { ...parsed, body: '' };
         if (depth === 'summary') {
@@ -110,6 +115,15 @@ export function createHafez(config) {
         }
         return parsed;
     }
+    /** The archive is an attachment of its entity, reached from it on purpose
+     * (#34): a disk read behind the entity's own slug, never an index row. */
+    async function archive(slug) {
+        const entity = resolveFilePath(vaultPath, slug, 'entity');
+        if (!existsSync(entity))
+            throw new HafezError('NOT_FOUND', `Entity '${slug}' not found`);
+        const path = archiveLogPath(vaultPath, slug);
+        return existsSync(path) ? readFileSync(path, 'utf-8') : null;
+    }
     function rollbackFiles(originals) {
         for (const [path, content] of originals) {
             if (content === null) {
@@ -216,12 +230,10 @@ export function createHafez(config) {
             const deletedAll = [...new Set(applied.flatMap(a => a.filesDeleted))];
             const finalize = () => {
                 updateIndexPostCommit(applied);
-                // index.md regeneration is gated: session-only writes skip it
-                if ([...writtenAll, ...deletedAll].some(isIndexedRelPath)) {
+                // index.md shows the mutable kinds: a session-only write leaves it.
+                if ([...writtenAll, ...deletedAll].some(isMutableRelPath)) {
                     regenerateIndexSafe();
                 }
-                // Session creates carry no index upserts — they are not indexed
-                // entities and never notified.
                 for (const a of applied) {
                     if (a.indexUpserts.length > 0)
                         onWrite?.(a.result.slug, single ? single.action : 'batch');
@@ -390,9 +402,11 @@ export function createHafez(config) {
             simulateLinks: (slug, links) => { simulatedLinks.set(slug, links); },
             // Read from disk, not the index: the validate phase must see the vault
             // as `validate` will, and a stale index row would let a linked note go.
+            // The mutable kinds only: a session note's related are a record of
+            // what it touched, and a record must not keep a note from being deleted.
             referrers: (slug) => {
                 const candidates = new Set(simulated.keys());
-                for (const kind of INDEXED_KINDS) {
+                for (const kind of MUTABLE_KINDS) {
                     for (const fp of scanVaultDir(join(vaultPath, kindDir(kind))))
                         candidates.add(basename(fp, '.md'));
                 }
@@ -476,6 +490,9 @@ export function createHafez(config) {
     async function validate() {
         return validateVault(vaultPath);
     }
+    async function health() {
+        return healthReport(vaultPath);
+    }
     async function promote(slug, target) {
         // Rollback safety rides the Spine: applyOperation's promote arm captures
         // both the source file and (for cross-kind moves) the knowledge target
@@ -491,7 +508,8 @@ export function createHafez(config) {
         knowledge_count: 0,
         stale: [], no_next_action: [], recently_touched: [], recently_created: [],
     };
-    return {
+    // An InternalHafez: syncIndex() is here, off the public Hafez type.
+    const hafez = {
         read,
         update,
         promote,
@@ -518,8 +536,13 @@ export function createHafez(config) {
         children: async (slug) => withIndex(idx => idx.queryChildren(slug), { items: [], total: 0 }),
         related_to: async (slug, relation) => withIndex(idx => idx.queryRelatedTo(slug, relation), { items: [], total: 0 }),
         query_knowledge: async (opts) => withIndex(idx => idx.queryKnowledge(opts), { items: [], total: 0 }),
+        query_sessions: async (opts) => withIndex(idx => idx.querySessions(opts), { items: [], total: 0 }),
+        archive,
         validate,
-        search: async (query, kind) => withIndex(idx => { idx.syncIfStale(); return idx.search(query, kind); }, []),
+        health,
+        search: async (query, kind) => withIndex(idx => { idx.syncForRead(); return idx.search(query, kind); }, []),
+        graph: async (opts) => withIndex(idx => idx.queryGraph(opts), { nodes: [], edges: [] }),
+        syncIndex: async () => { withIndex(idx => idx.syncIfStale(), undefined); },
         rebuildIndex: async () => {
             if (readOnly)
                 throw new HafezError('VALIDATION_FAILED', 'Hafez instance is read-only');
@@ -533,14 +556,39 @@ export function createHafez(config) {
             const idx = getIndex();
             if (!idx)
                 return emptyStats;
-            idx.syncIfStale();
+            idx.syncForRead();
             const s = idx.getStats();
             s.recently_touched = await rankRecents(s.recently_touched, 'last_touched', 'modified');
             s.recently_created = await rankRecents(s.recently_created, 'created', 'added');
             return s;
         },
-        changelog: (since) => journal.changelog(since),
+        changelog: async (since, limit) => {
+            if (limit !== undefined && !(Number.isInteger(limit) && limit > 0)) {
+                throw new HafezError('VALIDATION_FAILED', `changelog limit must be a positive whole number of commits, got ${limit}`);
+            }
+            return journal.changelog(since, limit);
+        },
+        changesSince: async (cursor) => {
+            const { cursor: next, files } = await journal.changesSince(cursor);
+            const changes = files.flatMap(({ path, op }) => {
+                const note = noteAtRelPath(path);
+                return note ? [{ ...note, op }] : [];
+            });
+            return { cursor: next, changes };
+        },
+        close: () => {
+            // Forget the handle even if closing it throws: a retry must not
+            // re-throw, and getIndex() must never hand out a closed handle.
+            try {
+                _index?.close();
+            }
+            finally {
+                _index = null;
+                _indexInitialized = false;
+            }
+        },
     };
+    return hafez;
 }
 export { HafezError } from './types.js';
 export { getBrief, getNextActions } from './document.js';

package/dist/internal.d.ts

@@ -0,0 +1,21 @@
+import type { Hafez, HafezConfig } from './types.js';
+import type { IndexSync } from './db.js';
+export interface InternalHafezConfig extends HafezConfig {
+    /** When the index catches up with files changed outside hafez (a hand edit,
+     * a raw git pull). 'read' (default): before every index read, a stat per
+     * note, so a long-lived instance never reads a stale index. 'once': the
+     * first index read syncs, later reads trust the index — the CLI's mode, one
+     * scan per process (#269); a file changed outside hafez after that read is
+     * seen by the next process, or after `syncIndex()`. Writes through the
+     * instance are indexed as they commit in every mode. 'manual': reads trust
+     * the index, and `syncIndex()` syncs it — the graph server's mode, which
+     * syncs when its poll sees a commit (#271). */
+    indexSync?: IndexSync;
+}
+export interface InternalHafez extends Hafez {
+    /** Catch the index up with files changed outside hafez, in every mode:
+     * what a read does first under `indexSync` 'read', and the first read under 'once'. */
+    syncIndex(): Promise<void>;
+}
+/** createHafez with the internal options: every instance it builds is an InternalHafez. */
+export declare function createInternalHafez(config: InternalHafezConfig): InternalHafez;

package/dist/internal.js

@@ -0,0 +1,9 @@
+// src/internal.ts
+// What hafez's own CLI and graph server reach that the package does not
+// export: src/index.ts re-exports none of it, and package.json's `exports`
+// map stops a deep import. Off the library surface by the owner's call (#270).
+import { createHafez } from './index.js';
+/** createHafez with the internal options: every instance it builds is an InternalHafez. */
+export function createInternalHafez(config) {
+    return createHafez(config);
+}

package/dist/knowledge-index.d.ts

@@ -5,7 +5,7 @@
  * imports from this file. */
 export interface VaultIndexRow {
     slug: string;
-    kind: 'entity' | 'knowledge';
+    kind: 'entity' | 'knowledge' | 'session';
     name: string;
     type: string | null;
     status: string | null;

package/dist/read-json.d.ts

@@ -0,0 +1,26 @@
+import type { Hafez, ParsedFile, ReadDepth } from './types.js';
+import { type Workstream } from './workstream.js';
+import { type ChildLine, type FooterInput } from './surfaces/items.js';
+/** `read --json`'s object for a note read at `depth`: what the CLI prints and
+ * what the graph server's `/note/:slug` serves. `whole`, its full-depth read
+ * when the caller holds one, saves reading it again. */
+export declare function readJsonOf(os: Hafez, slug: string, depth: ReadDepth, result: ParsedFile, whole?: ParsedFile): Promise<object>;
+/** What hangs off an entity elsewhere: the sessions that touched it (the
+ * look back, #35), its archived log entries (#34), its children (#230) and
+ * the prefix families its own Next Actions carry unsplit against the
+ * entities whose `parent` or `related` names it (#230). Counted at read
+ * time, nothing written. */
+export declare function pointersFor(os: Hafez, slug: string, body: string): Promise<{
+    sessions: {
+        count: number;
+        latest: string | null;
+    };
+    archive_entries: number;
+    children: ChildLine[];
+    workstreams: Workstream[];
+}>;
+/** The Footer for a file read at full depth: its Handle comes from the
+ * whole file. A session note has none: it is never written to. */
+export declare function footerFor(slug: string, result: Exclude<ParsedFile, {
+    kind: 'session';
+}>): FooterInput;

package/dist/read-json.js

@@ -0,0 +1,53 @@
+import { detectAgent } from './harness.js';
+import { getActionItems, parseSessionLogHeading } from './document.js';
+import { agedActions } from './stale.js';
+import { workstreams } from './workstream.js';
+import { CHILDREN_SHOWN, footerOp } from './surfaces/items.js';
+/** `read --json`'s object for a note read at `depth`: what the CLI prints and
+ * what the graph server's `/note/:slug` serves. `whole`, its full-depth read
+ * when the caller holds one, saves reading it again. */
+export async function readJsonOf(os, slug, depth, result, whole) {
+    // A session note is read, never written: no Footer (#35).
+    if (result.kind === 'session')
+        return result;
+    // The Footer and the pointers are the same at every depth: they read the
+    // whole file, not the body this depth shows.
+    const full = (whole ?? (depth === 'full' ? result : await os.read(slug, 'full')));
+    const writes = footerOp(footerFor(slug, full));
+    const pointers = full.kind === 'entity' ? await pointersFor(os, slug, full.body) : null;
+    const json = pointers && { ...pointers, children: pointers.children.slice(0, CHILDREN_SHOWN), children_total: pointers.children.length };
+    // A frontmatter-depth read carries no body, so it has no actions to list.
+    if (result.kind !== 'entity' || depth === 'frontmatter')
+        return { ...result, ...json, writes };
+    return { ...result, actions: agedActions(result.body, result.frontmatter), ...json, writes };
+}
+/** What hangs off an entity elsewhere: the sessions that touched it (the
+ * look back, #35), its archived log entries (#34), its children (#230) and
+ * the prefix families its own Next Actions carry unsplit against the
+ * entities whose `parent` or `related` names it (#230). Counted at read
+ * time, nothing written. */
+export async function pointersFor(os, slug, body) {
+    const relatedTo = (await os.related_to(slug)).items;
+    const sessions = relatedTo.filter((i) => i.kind === 'session');
+    const latest = sessions.reduce((max, s) => (max === null || s.session_date > max ? s.session_date : max), null);
+    const archive = await os.archive(slug);
+    const entries = archive ? archive.split('\n').filter(line => parseSessionLogHeading(line)).length : 0;
+    // The children block (#230): the index's children query, last-touched
+    // descending then slug for a stable order; the renders cap what is shown.
+    const childItems = (await os.children(slug)).items;
+    const children = [...childItems]
+        .sort((a, b) => b.last_touched.localeCompare(a.last_touched) || a.slug.localeCompare(b.slug))
+        .map(c => ({ slug: c.slug, description: c.description, open_actions: c.next_action_count, last_touched: c.last_touched }));
+    const naming = [...childItems, ...relatedTo.filter(i => i.kind === 'entity')];
+    return { sessions: { count: sessions.length, latest }, archive_entries: entries, children, workstreams: workstreams(body, naming) };
+}
+/** The Footer for a file read at full depth: its Handle comes from the
+ * whole file. A session note has none: it is never written to. */
+export function footerFor(slug, result) {
+    return { slug, agent: detectAgent(), ...(result.kind === 'entity'
+            ? {
+                target: { kind: 'entity', type: result.frontmatter.type },
+                handle: getActionItems(result.body).find(a => a.handle)?.handle,
+            }
+            : { target: { kind: 'knowledge', subtype: result.frontmatter.subtype } }) };
+}

package/dist/schema.d.ts

@@ -1,5 +1,7 @@
 export declare function validateEntityFrontmatter(fm: Record<string, any>): string[];
 export declare function validateKnowledgeFrontmatter(fm: Record<string, any>): string[];
+/** A session note: its name and created stamp, nothing else is required. */
+export declare function validateSessionFrontmatter(fm: Record<string, any>): string[];
 export declare function validateKnowledgeSubtype(fm: Record<string, any>): string[];
 export declare function validateSlugReference(slug: string, field: string, exists: (s: string) => boolean): string | null;
 export declare function validateSessionLogEntry(entry: {

package/dist/schema.js

@@ -30,6 +30,17 @@ export function validateKnowledgeFrontmatter(fm) {
     errors.push(...validateKnowledgeSubtype(fm));
     return errors;
 }
+/** A session note: its name and created stamp, nothing else is required. */
+export function validateSessionFrontmatter(fm) {
+    const errors = [];
+    if (!fm.name || typeof fm.name !== 'string')
+        errors.push('missing required field: name');
+    if (!fm.created)
+        errors.push('missing required field: created');
+    if (fm.related !== undefined && !Array.isArray(fm.related))
+        errors.push('session related must be an array');
+    return errors;
+}
 export function validateKnowledgeSubtype(fm) {
     const errors = [];
     if (fm.subtype && !VALID_SUBTYPES.includes(fm.subtype)) {

package/dist/stale.d.ts

@@ -9,8 +9,8 @@ export interface ActionAge {
 }
 /** The entity side of the rule, as SQL over an index row `i` with `@today`
  * bound to localDay(): whole days from its last-touched day to today.
- * julianday of two bare YYYY-MM-DD days differs by exactly `dayNumber`'s
- * difference, so entities and their actions count the same days. */
+ * julianday of two bare YYYY-MM-DD days differs by exactly `daysBetween`
+ * (src/dates.ts), so entities and their actions count the same days. */
 export declare const ENTITY_AGE_DAYS_SQL = "CAST(julianday(@today) - julianday(i.last_touched) AS INTEGER)";
 /** An entity row is stale when its age is past its threshold, not equal to
  * it — `actionAge`'s rule. */

package/dist/stale.js

@@ -2,19 +2,14 @@
 // Stale (see CONTEXT.md): past the entity's `staleness-days` without
 // movement. An open next action is stale when unticked that long since its
 // added day; an undated one is stale. Ages count local days (src/dates.ts).
-import { localDay } from './dates.js';
+import { daysBetween, localDay } from './dates.js';
 import { getActionItems } from './document.js';
 /** The threshold an entity without `staleness-days` gets. */
 export const DEFAULT_STALENESS_DAYS = 14;
-/** A YYYY-MM-DD day as a whole day count, so differences ignore DST. */
-const dayNumber = (day) => {
-    const [y, m, d] = day.split('-').map(Number);
-    return Date.UTC(y, m - 1, d) / 86_400_000;
-};
 /** The entity side of the rule, as SQL over an index row `i` with `@today`
  * bound to localDay(): whole days from its last-touched day to today.
- * julianday of two bare YYYY-MM-DD days differs by exactly `dayNumber`'s
- * difference, so entities and their actions count the same days. */
+ * julianday of two bare YYYY-MM-DD days differs by exactly `daysBetween`
+ * (src/dates.ts), so entities and their actions count the same days. */
 export const ENTITY_AGE_DAYS_SQL = 'CAST(julianday(@today) - julianday(i.last_touched) AS INTEGER)';
 /** An entity row is stale when its age is past its threshold, not equal to
  * it — `actionAge`'s rule. */
@@ -24,7 +19,7 @@ export const ENTITY_STALE_SQL = `${ENTITY_AGE_DAYS_SQL} > COALESCE(i.staleness_d
 export function actionAge(added, stalenessDays, today = localDay()) {
     if (added === null)
         return { added, age_days: null, stale: true };
-    const age_days = dayNumber(today) - dayNumber(added);
+    const age_days = daysBetween(added, today);
     return { added, age_days, stale: age_days > stalenessDays };
 }
 /** An entity's threshold: its `staleness-days`, else the default. */

package/dist/surfaces/items.d.ts

@@ -1,6 +1,7 @@
 import { type DocTarget, type WriteLineField } from '../contracts.js';
 import { renderActionHandles } from '../document.js';
 import type { ActionAge } from '../stale.js';
+import type { Workstream } from '../workstream.js';
 import type { KnowledgeSubtype, UpdateFields, UpdateResult } from '../types.js';
 import { type OnboardHarness } from '../harness.js';
 import type { Mode } from '../cli/install.js';
@@ -9,6 +10,11 @@ import type { Mode } from '../cli/install.js';
 export type SurfaceId = 'block' | 'hafezSkillDescription' | 'hafezSkillBody' | 'hafezSaveDescription' | 'hafezSaveBody' | 'read' | 'readHeader' | 'readFooter' | 'readMiss' | 'updateSuccess' | 'updateMisuse' | 'createKnowledge' | 'digestError' | 'batchMisuse' | 'mechanised' | 'schema' | 'onboard';
 /** Places another Item inside this one's text, counted against the same Surface. */
 export type Place = (id: string) => string;
+/** What a static Surface is composed for. `vaultRepo`: the Block for a cloud
+ * container, whose vault is that GitHub repo (#160). */
+export interface SurfaceCtx {
+    vaultRepo?: string;
+}
 export interface Item {
     /** The Item's row text in the owner table. */
     label: string;
@@ -21,7 +27,7 @@ export interface Item {
     evidence: string;
     /** Static text. A function form may place nested Items, and may give the
      * fallback a shorter form than the Owner. */
-    text?: string | ((place: Place, at: 'owner' | 'fallback') => string);
+    text?: string | ((place: Place, at: 'owner' | 'fallback', ctx: SurfaceCtx) => string);
     /** What the binary computes: for Items owned by command output, and for a
      * static Item a binary Surface places filled in (the create line in the
      * `read` miss). */
@@ -94,6 +100,41 @@ declare function renderUpdateSummary({ slug, fields, result }: {
 /** The suffix a Stale open line carries on `read`: its age, or that it is
  * undated. A fresh line carries none. */
 declare function renderStaleMarker({ stale, age_days }: ActionAge): string;
+/** The `read` header line naming the sessions that touched an entity, with
+ * the look back from it. None: no line. */
+declare function renderSessionsLine({ slug, count, latest }: {
+    slug: string;
+    count: number;
+    latest: string | null;
+}): string;
+/** The `read` header line naming an entity's archived log entries, with the
+ * command that reads them. No archive: no line. */
+declare function renderArchivePointer({ slug, entries }: {
+    slug: string;
+    entries: number;
+}): string;
+/** A child as the `read` header shows it. */
+export interface ChildLine {
+    slug: string;
+    description: string | null;
+    open_actions: number;
+    last_touched: string;
+}
+/** How many children the header lists; the rest are one overflow line. */
+export declare const CHILDREN_SHOWN = 5;
+/** The `read` header's children block: the count line (children, open
+ * actions across all of them), one `hafez read` line per child (description,
+ * open count, last-touched day) for the first `CHILDREN_SHOWN`, and the
+ * overflow line naming the query that lists the rest. Children arrive sorted
+ * by last-touched descending. No children: no block. */
+declare function renderChildrenBlock({ slug, children }: {
+    slug: string;
+    children: ChildLine[];
+}): string;
+/** The `read` header's fact line for one unsplit prefix family (#230):
+ * its open-line count and the family, and that no child carries it. A
+ * fact, never a filled create line or a question. */
+declare function renderWorkstreamLine({ prefix, open_actions }: Workstream): string;
 /** The line after an update's success while Stale lines remain on the entity. */
 declare function renderStaleReminder({ handles }: {
     handles: string[];
@@ -129,6 +170,15 @@ declare function renderTeachingLines({ harness, mode, line2Only }: {
     mode: Mode;
     line2Only?: boolean;
 }): string;
+/** A GitHub `<owner>/<repo>`, as one shell word safe to print in a command
+ * and to name a directory by: not `.` or `..`, not a clone URL's `.git`. */
+export declare const isVaultRepo: (value: string) => boolean;
+/** `onboard --cloud`: the cloud environment's setup script. It cannot clone
+ * (it runs without GitHub credentials) and no step may fail session start: a
+ * failed install exits 0, leaving a session without Hafez rather than none. */
+declare function renderCloudSetup({ vaultRepo }: {
+    vaultRepo: string;
+}): string;
 export declare const ITEMS: {
     loadTriggers: {
         label: string;
@@ -159,6 +209,34 @@ export declare const ITEMS: {
             description: string | null;
         }) => string;
     };
+    childrenBlock: {
+        label: string;
+        owner: "readHeader";
+        invokeOnly: string;
+        evidence: string;
+        render: typeof renderChildrenBlock;
+    };
+    workstreamLine: {
+        label: string;
+        owner: "readHeader";
+        invokeOnly: string;
+        evidence: string;
+        render: typeof renderWorkstreamLine;
+    };
+    sessionsLine: {
+        label: string;
+        owner: "readHeader";
+        invokeOnly: string;
+        evidence: string;
+        render: typeof renderSessionsLine;
+    };
+    archivePointer: {
+        label: string;
+        owner: "readHeader";
+        invokeOnly: string;
+        evidence: string;
+        render: typeof renderArchivePointer;
+    };
     writeTriggers: {
         label: string;
         owner: "block";
@@ -319,6 +397,13 @@ export declare const ITEMS: {
         evidence: string;
         text: string;
     };
+    healthProcedure: {
+        label: string;
+        owner: "hafezSkillBody";
+        invokeOnly: string;
+        evidence: string;
+        text: string;
+    };
     batchShape: {
         label: string;
         owner: "hafezSkillBody";
@@ -354,6 +439,20 @@ export declare const ITEMS: {
         evidence: string;
         render: typeof renderHarnessPermissions;
     };
+    cloudVault: {
+        label: string;
+        owner: "block";
+        invokeOnly: string;
+        evidence: string;
+        text: (_place: Place, _at: "owner" | "fallback", { vaultRepo }: SurfaceCtx) => string;
+    };
+    cloudSetup: {
+        label: string;
+        owner: "onboard";
+        invokeOnly: string;
+        evidence: string;
+        render: typeof renderCloudSetup;
+    };
     teachingLines: {
         label: string;
         owner: "onboard";