hafez 2.0.0 → 2.1.0

package/dist/apply.js

@@ -50,7 +50,7 @@ function entityPath(vaultPath, slug) { return resolveFilePath(vaultPath, slug, '
 function knowledgePath(vaultPath, slug) { return resolveFilePath(vaultPath, slug, 'knowledge'); }
 function today() { return localDay(); }
 // --- Field policy ---
-const ENTITY_ONLY_FIELDS = ['status', 'add_action', 'add_actions', 'complete_action', 'remove_action', 'clear_actions', 'brief', 'current_state', 'session_log', 'agent', 'resource', 'parent'];
+const ENTITY_ONLY_FIELDS = ['status', 'add_action', 'add_actions', 'complete_action', 'complete_actions', 'remove_action', 'remove_actions', 'clear_actions', 'brief', 'current_state', 'session_log', 'agent', 'resource', 'parent'];
 const KNOWLEDGE_ONLY_FIELDS = ['confidence', 'synthesis', 'add_evidence', 'add_source'];
 // An entity-only field is still reachable on a knowledge note when THAT
 // note's contract declares the capability the field needs. The gate asks the
@@ -185,8 +185,8 @@ export function buildKnowledgeFrontmatter(name, kf, existsFn) {
 }
 // The Next Actions fields are the one group in UpdateFields that all touch
 // the same section, so their order within an op IS their meaning. The
-// contract: prune, tick, add — clear_actions → remove_action →
-// complete_action → add_action → add_actions. Every query is resolved
+// contract: prune, tick, add — clear_actions → remove_action(s) →
+// complete_action(s) → add_action → add_actions. Every query is resolved
 // against the list as it stands after the clear and before any edit, so a
 // query never sees a line another field of the same op removed or added;
 // two queries naming one line is a collision, not a silent overwrite. The
@@ -207,27 +207,51 @@ const ARCHIVE_LIMIT = 10;
 function applyNextActionFields(doc, body, fields) {
     const result = {};
     const cleared = fields.clear_actions ? doc.actionLines(body) : [];
-    let removedLine;
     if (fields.clear_actions)
         body = doc.clearNextActions(body);
-    const removed = fields.remove_action !== undefined ? doc.matchNextAction(body, fields.remove_action) : undefined;
-    const completed = fields.complete_action !== undefined ? doc.matchNextAction(body, fields.complete_action) : undefined;
+    const match = (field, query) => ({ field, match: doc.matchNextAction(body, query) });
+    const removes = [
+        ...(fields.remove_action !== undefined ? [match('remove_action', fields.remove_action)] : []),
+        ...(fields.remove_actions ?? []).map(q => match('remove_actions', q)),
+    ];
+    const completes = [
+        ...(fields.complete_action !== undefined ? [match('complete_action', fields.complete_action)] : []),
+        ...(fields.complete_actions ?? []).map(q => match('complete_actions', q)),
+    ];
     // Caller misuse, not a Spine bug: like no-match and ambiguous (matchNextAction),
     // it depends on the list as the earlier ops of a batch leave it, so it is
     // resolved here rather than in the validate phase.
-    if (removed && completed && removed.line === completed.line) {
-        throw new HafezError('VALIDATION_FAILED', `remove_action and complete_action both match "${removed.text}" — one line, one field`);
+    const seen = new Map();
+    for (const { field, match: m } of [...removes, ...completes]) {
+        const first = seen.get(m.line);
+        if (first !== undefined) {
+            throw new HafezError('VALIDATION_FAILED', first === field
+                ? `${field} matches "${m.text}" twice — one line, one query`
+                : `${first} and ${field} both match "${m.text}" — one line, one field`);
+        }
+        seen.set(m.line, field);
+    }
+    // The singular query, when sent, is first in its list; the array form is the rest.
+    const texts = (list) => list.map(q => q.match.text);
+    const removeOffset = fields.remove_action !== undefined ? 1 : 0;
+    const completeOffset = fields.complete_action !== undefined ? 1 : 0;
+    if (removeOffset)
+        result.removed_action = removes[0].match.text;
+    if (fields.remove_actions !== undefined)
+        result.removed_actions = texts(removes.slice(removeOffset));
+    if (completeOffset)
+        result.completed_action = completes[0].match.text;
+    if (fields.complete_actions !== undefined)
+        result.completed_actions = texts(completes.slice(completeOffset));
+    // Every match is a line position in the pre-edit list. A tick leaves every
+    // position where it was; a removal shifts the lines below it — so tick
+    // first, then remove bottom-up. The archive keeps query order.
+    for (const { match: m } of completes)
+        body = doc.completeNextAction(body, m).body;
+    const removed = [];
+    for (const i of removes.map((_, i) => i).sort((x, y) => removes[y].match.line - removes[x].match.line)) {
+        ({ body, line: removed[i] } = doc.removeNextAction(body, removes[i].match));
     }
-    if (removed)
-        result.removed_action = removed.text;
-    if (completed)
-        result.completed_action = completed.text;
-    // Both matches are line positions in the pre-edit list. A tick leaves every
-    // position where it was; a removal shifts the lines below it — so tick first.
-    if (completed)
-        body = doc.completeNextAction(body, completed).body;
-    if (removed)
-        ({ body, line: removedLine } = doc.removeNextAction(body, removed));
     if (fields.add_action !== undefined)
         body = addStampedAction(doc, body, fields.add_action);
     if (fields.add_actions !== undefined) {
@@ -241,7 +265,7 @@ function applyNextActionFields(doc, body, fields) {
     return {
         body: doc.pruneNextActions(overflow.body),
         result,
-        archived: { cleared, removed: removedLine, ticked: [...overflow.lines, ...pruned] },
+        archived: { cleared, removed, ticked: [...overflow.lines, ...pruned] },
     };
 }
 // Pure field application, like every arm above it: the Spine has already run
@@ -317,8 +341,8 @@ function archivedActionEntries(archived) {
         const n = archived.cleared.length;
         entries.push(formatSessionLogEntry({ type: 'progress', agent: 'system', summary: `Cleared ${n} action${plural(n)}`, body: archived.cleared.join('\n') }));
     }
-    if (archived.removed !== undefined) {
-        entries.push(formatSessionLogEntry({ type: 'progress', agent: 'system', summary: 'Removed action', body: archived.removed }));
+    for (const line of archived.removed) {
+        entries.push(formatSessionLogEntry({ type: 'progress', agent: 'system', summary: 'Removed action', body: line }));
     }
     const n = archived.ticked.length;
     if (n > 0) {

package/dist/batch-ops.d.ts

@@ -27,7 +27,9 @@ export declare const UpdateFieldsSchema: z.ZodObject<{
     add_action: z.ZodOptional<z.ZodString>;
     add_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     complete_action: z.ZodOptional<z.ZodString>;
+    complete_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     remove_action: z.ZodOptional<z.ZodString>;
+    remove_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     clear_actions: z.ZodOptional<z.ZodBoolean>;
     parent: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -110,7 +112,9 @@ export declare const BatchOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         add_action: z.ZodOptional<z.ZodString>;
         add_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
         complete_action: z.ZodOptional<z.ZodString>;
+        complete_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
         remove_action: z.ZodOptional<z.ZodString>;
+        remove_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
         clear_actions: z.ZodOptional<z.ZodBoolean>;
         parent: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -279,7 +283,9 @@ declare const OP_SPEC_ROWS: readonly [{
             add_action: z.ZodOptional<z.ZodString>;
             add_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
             complete_action: z.ZodOptional<z.ZodString>;
+            complete_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
             remove_action: z.ZodOptional<z.ZodString>;
+            remove_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
             clear_actions: z.ZodOptional<z.ZodBoolean>;
             parent: z.ZodOptional<z.ZodString>;
             description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -296,7 +302,7 @@ declare const OP_SPEC_ROWS: readonly [{
             add_source: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
     }, z.core.$strict>;
-    readonly description: "Update an entity or knowledge note (status, brief, next actions, session log, synthesis, …). Next Actions fields compose within one op as prune, tick, add: `clear_actions` → `remove_action` → `complete_action` → `add_action(s)` — queries match the list as it was before the op (two queries naming one line is an error), added lines land last, so `clear_actions` + `add_actions` rebuilds the list; `clear_actions` with a query field is rejected. Lines leaving the list (removed, cleared, pruned with an emptied section, ticked past nine, oldest first) move to the entity's archive log. A Handle of an open action (as `read` shows it, or any longer or shorter prefix of four or more hex that names only that line) names that line; anything else is a case-insensitive substring of the text. `parent` sets the parent link (entity-only; the slug must exist, and the parent chain must not lead back to the entity). `insight` is an alias for `synthesis` (knowledge-only; ignored when `synthesis` is also given). An entity update with no `session_log` gets a `progress` entry naming the fields written, unless its only fields are action fields; `agent` names the agent on it (entity-only, detected from the Harness when absent, rejected alongside `session_log`). On knowledge notes `status` is plan-subtype only (active|done); insights reject it.";
+    readonly description: "Update an entity or knowledge note (status, brief, next actions, session log, synthesis, …). Next Actions fields compose within one op as prune, tick, add: `clear_actions` → `remove_action(s)` → `complete_action(s)` → `add_action(s)` — queries match the list as it was before the op (two queries naming one line is an error), added lines land last, so `clear_actions` + `add_actions` rebuilds the list; `clear_actions` with a query field is rejected. Lines leaving the list (removed, cleared, pruned with an emptied section, ticked past nine, oldest first) move to the entity's archive log. A Handle of an open action (as `read` shows it, or any longer or shorter prefix of four or more hex that names only that line) names that line; anything else is a case-insensitive substring of the text. `parent` sets the parent link (entity-only; the slug must exist, and the parent chain must not lead back to the entity). `insight` is an alias for `synthesis` (knowledge-only; ignored when `synthesis` is also given). An entity update with no `session_log` gets a `progress` entry naming the fields written, unless its only fields are action fields; `agent` names the agent on it (entity-only, detected from the Harness when absent, rejected alongside `session_log`). On knowledge notes `status` is plan-subtype only (active|done); insights reject it.";
     readonly exampleInclude: readonly ["status"];
     readonly check: (op: Extract<BatchOperation, {
         op: "update";

package/dist/batch-ops.js

@@ -52,7 +52,9 @@ export const UpdateFieldsSchema = z.object({
     add_action: nonEmptyText.optional(),
     add_actions: z.array(nonEmptyText).optional(),
     complete_action: nonEmptyText.optional(),
+    complete_actions: z.array(nonEmptyText).min(1).optional(),
     remove_action: nonEmptyText.optional(),
+    remove_actions: z.array(nonEmptyText).min(1).optional(),
     clear_actions: z.boolean().optional(),
     parent: z.string().optional(), // entity-only; the slug must exist, no cycle
     // Knowledge metadata
@@ -120,7 +122,7 @@ const CreateSessionBranch = z.object({
 }).strict();
 /** Update fields the mechanised session log neither counts nor names:
  * ticking a box is not history worth an entry, and `agent` only names it. */
-const UNLOGGED_FIELDS = new Set(['add_action', 'add_actions', 'complete_action', 'remove_action', 'clear_actions', 'agent']);
+const UNLOGGED_FIELDS = new Set(['add_action', 'add_actions', 'complete_action', 'complete_actions', 'remove_action', 'remove_actions', 'clear_actions', 'agent']);
 /** The fields an update's mechanised session log entry names — empty when
  * the update earns none. Shared by the update check (which rejects an
  * `agent` with no entry to name) and the Apply update arm (which writes it). */
@@ -316,7 +318,7 @@ const OP_SPEC_ROWS = [
         name: 'update',
         op: 'update',
         schema: UpdateBranch,
-        description: 'Update an entity or knowledge note (status, brief, next actions, session log, synthesis, …). Next Actions fields compose within one op as prune, tick, add: `clear_actions` → `remove_action` → `complete_action` → `add_action(s)` — queries match the list as it was before the op (two queries naming one line is an error), added lines land last, so `clear_actions` + `add_actions` rebuilds the list; `clear_actions` with a query field is rejected. Lines leaving the list (removed, cleared, pruned with an emptied section, ticked past nine, oldest first) move to the entity\'s archive log. A Handle of an open action (as `read` shows it, or any longer or shorter prefix of four or more hex that names only that line) names that line; anything else is a case-insensitive substring of the text. `parent` sets the parent link (entity-only; the slug must exist, and the parent chain must not lead back to the entity). `insight` is an alias for `synthesis` (knowledge-only; ignored when `synthesis` is also given). An entity update with no `session_log` gets a `progress` entry naming the fields written, unless its only fields are action fields; `agent` names the agent on it (entity-only, detected from the Harness when absent, rejected alongside `session_log`). On knowledge notes `status` is plan-subtype only (active|done); insights reject it.',
+        description: 'Update an entity or knowledge note (status, brief, next actions, session log, synthesis, …). Next Actions fields compose within one op as prune, tick, add: `clear_actions` → `remove_action(s)` → `complete_action(s)` → `add_action(s)` — queries match the list as it was before the op (two queries naming one line is an error), added lines land last, so `clear_actions` + `add_actions` rebuilds the list; `clear_actions` with a query field is rejected. Lines leaving the list (removed, cleared, pruned with an emptied section, ticked past nine, oldest first) move to the entity\'s archive log. A Handle of an open action (as `read` shows it, or any longer or shorter prefix of four or more hex that names only that line) names that line; anything else is a case-insensitive substring of the text. `parent` sets the parent link (entity-only; the slug must exist, and the parent chain must not lead back to the entity). `insight` is an alias for `synthesis` (knowledge-only; ignored when `synthesis` is also given). An entity update with no `session_log` gets a `progress` entry naming the fields written, unless its only fields are action fields; `agent` names the agent on it (entity-only, detected from the Harness when absent, rejected alongside `session_log`). On knowledge notes `status` is plan-subtype only (active|done); insights reject it.',
         exampleInclude: ['status'],
         check(op, ctx) {
             const errors = [];
@@ -341,9 +343,9 @@ const OP_SPEC_ROWS = [
             // only — on a knowledge note validateKindFields has already rejected
             // the fields themselves, and a second error about their order is noise.
             if (target?.kind === 'entity' && op.fields.clear_actions) {
-                const queries = ['remove_action', 'complete_action'].filter(f => op.fields[f] !== undefined);
+                const queries = ['remove_action', 'remove_actions', 'complete_action', 'complete_actions'].filter(f => op.fields[f] !== undefined);
                 if (queries.length > 0) {
-                    errors.push(`clear_actions empties the list before ${queries.join(' and ')} would run — drop the clear or use a separate op`);
+                    errors.push(`clear_actions empties the list before ${queries.slice(0, -1).join(', ')}${queries.length > 1 ? ' and ' : ''}${queries.at(-1)} would run — drop the clear or use a separate op`);
                 }
             }
             // `agent` names the entry the Spine adds; with nothing added it would be

package/dist/cli/commands.js

@@ -356,11 +356,11 @@ export async function cmdCreate(os, args, opts = {}) {
     }
     throw new UsageError(`Unknown kind: ${kind}. Use entity or knowledge.`);
 }
-const UPDATE_USAGE = 'Usage: hafez update <slug> [--brief text] [--description text] [--resource uri] [--add-action text (repeats)] [--complete-action handle-or-text] [--remove-action handle-or-text] [--clear-actions] [--status <active|paused|done>] [--parent slug] [--log "<progress|decision|blocker|research>: summary" [--body text]]';
+const UPDATE_USAGE = 'Usage: hafez update <slug> [--brief text] [--description text] [--resource uri] [--add-action text (repeats)] [--complete-action handle-or-text (repeats)] [--remove-action handle-or-text (repeats)] [--clear-actions] [--status <active|paused|done>] [--parent slug] [--log "<progress|decision|blocker|research>: summary" [--body text]]';
 /** Exported so tests can assert the table covers the update schema. */
 export const UPDATE_FLAGS = {
     status: 'string', 'current-state': 'string', brief: 'string',
-    'add-action': 'repeat', 'complete-action': 'string', 'remove-action': 'string',
+    'add-action': 'repeat', 'complete-action': 'repeat', 'remove-action': 'repeat',
     'clear-actions': 'boolean', parent: 'string',
     description: 'string', resource: 'string', domain: 'string', confidence: 'string',
     tags: 'string', related: 'string', insight: 'string', synthesis: 'string',

package/dist/cli/index.js

@@ -88,9 +88,9 @@ Commands:
     --brief "text"           Set/replace Brief (use --brief "" to clear)
     --description "text"     Set one-line description (use --description "" to clear)
     --resource "uri"         Set canonical resource URI, entities only (use --resource "" to clear)
-    --add-action "text"      Add a next action
-    --complete-action handle-or-text  Complete the action with that Handle (as read shows it), else the matching one
-    --remove-action handle-or-text    Remove the action with that Handle, else the matching one
+    --add-action "text"      Add a next action (repeats)
+    --complete-action handle-or-text  Complete the action with that Handle (as read shows it), else the matching one (repeats)
+    --remove-action handle-or-text    Remove the action with that Handle, else the matching one (repeats)
     --clear-actions          Remove all next actions
     --synthesis "text"       Set/replace Synthesis section (--insight is an alias)
     --add-evidence "text"    Append to Evidence section

package/dist/cli/install.d.ts

@@ -6,6 +6,10 @@ export declare const SKILL_DIRS: string[];
 export type HashState = 'absent' | 'current' | 'stale' | 'hand-edited';
 /** What to do about broken markers: a hand edit, then `rerun`. */
 export declare const fixBrokenMarkers: (path: string, rerun: string) => string;
+/** What to do about a 1.x section: Hafez cannot tell where it ends. */
+export declare const removeLegacy: (path: string, line: number) => string;
+/** The status line for a 1.x section. */
+export declare const legacyLine: (path: string, line: number) => string;
 /** Codex reads an `AGENTS.override.md` in place of `AGENTS.md` when one
  * exists: the first candidate present, else the last. */
 export declare const instructionsFile: (home: string, candidates: readonly string[]) => string;
@@ -18,6 +22,8 @@ export interface InstallState {
     skills: HashState;
     /** Some skill file carries a hash: `onboard --install` has run here. */
     onboarded: boolean;
+    /** The line of a 1.x section in the instructions file, else null. */
+    legacy: number | null;
 }
 export declare function installState(home: string, harness: HarnessId): InstallState;
 export declare function install(opts: {
@@ -38,12 +44,18 @@ export interface BlockCheck {
     /** The Block Hafez writes has changed since this one was written. */
     renderChanged: boolean;
 }
+export interface LegacyCheck {
+    harness: HarnessId;
+    path: string;
+    line: number;
+}
 /** Both skills in both directories, and the Block in the instructions file
  * each Harness reads — the one `--install` would write. Only Blocks that are
- * there are listed: none means invoke-only. */
+ * there are listed: none, and no 1.x section, means invoke-only. */
 export declare function checkInstall(home: string): {
     skills: SkillCheck[];
     blocks: BlockCheck[];
+    legacy: LegacyCheck[];
 };
 /** Remove everything Hafez wrote: both skills from both directories, and the
  * Block region from every instructions file a Harness reads. Nothing else. */

package/dist/cli/install.js

@@ -75,6 +75,26 @@ function findRegion(file, displayPath) {
         text: file.slice(begin.start, end.start + END.length),
     };
 }
+// --- The 1.x section ---
+/** The heading 1.2–1.4 `onboard` had the agent paste, with no markers (#157). */
+const LEGACY_HEADING = '## Hafez — Session Memory';
+/** The 1-based line of a 1.x section outside the Block region, or null. With
+ * broken markers (`region` undefined) the region is unknown: every line is read. */
+function findLegacy(file, region) {
+    let offset = 0;
+    const lines = file.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const inside = region != null && offset >= region.start && offset < region.next;
+        if (!inside && lines[i].trimEnd() === LEGACY_HEADING)
+            return i + 1;
+        offset += lines[i].length + 1;
+    }
+    return null;
+}
+/** What to do about a 1.x section: Hafez cannot tell where it ends. */
+export const removeLegacy = (path, line) => `Remove the Hafez 1.x section in ${path}, from its heading \`${LEGACY_HEADING}\` (line ${line}) to the end of that section, after the user's yes. It has no markers, so Hafez does not delete it.`;
+/** The status line for a 1.x section. */
+export const legacyLine = (path, line) => `Legacy section in ${path}, line ${line}: \`${LEGACY_HEADING}\``;
 /** A line diff of the user's Block against the render: ` ` both, `-` theirs
  * only, `+` the render only. */
 function lineDiff(theirs, ours) {
@@ -207,14 +227,19 @@ function run({ header, steps, tail = [], unchanged, listAll }) {
 export function installState(home, harness) {
     const { instructions } = HARNESSES[harness];
     let block = null;
+    let legacy = null;
     if (instructions !== null) {
         const rel = instructionsFile(home, instructions);
+        const text = readInstalled(join(home, rel)) ?? '';
+        let region;
         try {
-            block = hashState(findRegion(readInstalled(join(home, rel)) ?? '', `~/${rel}`), RENDERED.text);
+            region = findRegion(text, `~/${rel}`);
+            block = hashState(region, RENDERED.text);
         }
         catch {
             block = 'broken';
         }
+        legacy = findLegacy(text, region);
     }
     const skills = SKILL_DIRS.flatMap(dir => SKILLS.map(({ name, render }) => {
         const text = readInstalled(join(home, dir, name, 'SKILL.md'));
@@ -224,7 +249,7 @@ export function installState(home, harness) {
     const states = new Set(skills.map(s => s.state));
     const [only] = states;
     const merged = states.size === 1 ? only : states.has('hand-edited') ? 'hand-edited' : 'stale';
-    return { block, skills: merged, onboarded: skills.some(s => s.hashed) };
+    return { block, skills: merged, onboarded: skills.some(s => s.hashed), legacy };
 }
 // --- The two commands ---
 export function install(opts) {
@@ -232,7 +257,8 @@ export function install(opts) {
     const { label, instructions } = HARNESSES[harness];
     const steps = skillSteps(home, 'write');
     const tail = [];
-    if (instructions === null) {
+    const rel = instructions === null ? null : instructionsFile(home, instructions);
+    if (rel === null) {
         if (mode === 'always-on') {
             steps.push({ line: `Block: printed below, for ${label}'s User Rules` });
             tail.push(`${label} keeps its User Rules in Settings, not a file, so the Block was not written. Show the user the Block below and ask them to paste it into ${label} Settings → Rules → User Rules, marker lines included.`, `\`\`\`\`\n${renderBlock()}\`\`\`\``);
@@ -244,24 +270,32 @@ export function install(opts) {
     else {
         steps.push(blockStep({
             home,
-            rel: instructionsFile(home, instructions),
+            rel,
             want: mode === 'always-on' ? 'write' : 'remove',
             confirm,
             rerun: `hafez onboard --install --harness ${harness} --mode ${mode} --confirm`,
             suffix: mode === 'invoke-only' ? ' (invoke-only)' : '',
         }));
     }
-    return run({ header: `${label}, ${mode}:`, steps, tail, unchanged: 'Nothing changed: the install is current.', listAll: true });
+    const out = run({ header: `${label}, ${mode}:`, steps, tail, unchanged: 'Nothing changed: the install is current.', listAll: true });
+    if (rel === null)
+        return out;
+    // A 1.x section loads beside the Block, or in place of invoke-only: named,
+    // never touched (#162). Read after the writes, so its line is where it is now.
+    const text = readInstalled(join(home, rel)) ?? '';
+    const line = findLegacy(text, findRegion(text, `~/${rel}`));
+    return line === null ? out : `${out}\n\n${removeLegacy(`~/${rel}`, line)}`;
 }
 /** Both skills in both directories, and the Block in the instructions file
  * each Harness reads — the one `--install` would write. Only Blocks that are
- * there are listed: none means invoke-only. */
+ * there are listed: none, and no 1.x section, means invoke-only. */
 export function checkInstall(home) {
     const skills = skillFiles(home).map(({ rel, render, text }) => ({
         path: `~/${rel}`,
         state: hashState(text === null ? null : parseSkill(text), render()),
     }));
     const blocks = [];
+    const legacy = [];
     for (const [harness, { instructions }] of Object.entries(HARNESSES)) {
         if (instructions === null)
             continue;
@@ -276,14 +310,16 @@ export function checkInstall(home) {
         }
         catch {
             blocks.push({ harness, path, state: 'broken', renderChanged: false });
-            continue;
         }
+        const line = findLegacy(text, region);
+        if (line !== null)
+            legacy.push({ harness, path, line });
         if (!region)
             continue;
         const state = hashState(region, RENDERED.text);
         blocks.push({ harness, path, state, renderChanged: region.hash !== RENDERED.hash });
     }
-    return { skills, blocks };
+    return { skills, blocks, legacy };
 }
 /** Remove everything Hafez wrote: both skills from both directories, and the
  * Block region from every instructions file a Harness reads. Nothing else. */

package/dist/cli/onboard.js

@@ -15,7 +15,7 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { UsageError, parseArgs, str } from './args.js';
 import { HARNESSES, ONBOARD_HARNESSES, detectAgent, isHarness, isOnboardHarness } from '../harness.js';
-import { MODES, SKILL_DIRS, fixBrokenMarkers, install, installState, instructionsFile, isMode, remove } from './install.js';
+import { MODES, SKILL_DIRS, fixBrokenMarkers, install, installState, instructionsFile, isMode, legacyLine, remove, removeLegacy } from './install.js';
 import { noVaultMessage, resolveVaultPath } from './resolve-vault.js';
 import { HafezError } from '../types.js';
 import { kindDir, scanVaultDir } from '../vault.js';
@@ -159,6 +159,9 @@ export function renderOnboard({ home, harness, vault }) {
         ...[{ ...HARNESSES[harness], state }, ...others]
             .filter(h => h.state.block === 'broken')
             .map(h => fixBrokenMarkers(`~/${instructionsFile(home, h.instructions)}`, 'hafez onboard')),
+        ...[{ ...HARNESSES[harness], state }, ...others]
+            .filter(h => h.state.legacy !== null)
+            .map(h => `${legacyLine(`~/${instructionsFile(home, h.instructions)}`, h.state.legacy)}, from Hafez 1.x, with no markers.`),
     ];
     // With the install current there is no install step: switching the Mode is
     // walked here, and re-running `onboard` afterwards walks what it changed.
@@ -187,6 +190,8 @@ export function renderOnboard({ home, harness, vault }) {
         steps.push({
             title: 'Install',
             body: [
+                // Either install leaves the 1.x section in place, beside the Block or alone.
+                ...(state.legacy === null ? [] : [`${removeLegacy(instructionsRel, state.legacy)} Do this before either install below.`, '']),
                 `Always-on: ${showBlock}`,
                 '',
                 'hafez onboard --install --mode always-on',
@@ -201,6 +206,9 @@ export function renderOnboard({ home, harness, vault }) {
             ].join('\n'),
         });
     }
+    if (installCurrent && state.legacy !== null) {
+        steps.push({ title: 'Remove the Hafez 1.x section', body: removeLegacy(instructionsRel, state.legacy) });
+    }
     if (!config.allowlist) {
         steps.push({ title: 'Allow the command', body: ITEMS.harnessPermissions.render({ harness, vault }) });
     }

package/dist/cli/upgrade.d.ts

@@ -1,4 +1,4 @@
-import { type BlockCheck, type SkillCheck } from './install.js';
+import { type BlockCheck, type LegacyCheck, type SkillCheck } from './install.js';
 export type Comparison = 'behind' | 'equal' | 'ahead' | 'unknown';
 /** `command` entries are directly executable (after user approval); `action`
  * entries are prose, so an agent that shells out every entry does not try to
@@ -21,11 +21,13 @@ export interface UpgradeState {
     alternativeInstall: string | null;
     steps: UpgradeStep[];
 }
-/** Mode is not stored: a Block present means always-on. */
+/** Mode is not stored: a Block present means always-on, and so does a 1.x
+ * section with no markers (`legacy`). */
 export interface Integration {
     mode: 'always-on' | 'invoke-only';
     blocks: BlockCheck[];
     skills: SkillCheck[];
+    legacy: LegacyCheck[];
 }
 export interface UpgradeDeps {
     fetch: typeof globalThis.fetch;

package/dist/cli/upgrade.js

@@ -29,7 +29,7 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { UsageError, helpIfAsked } from './args.js';
 import { HARNESSES, detectAgent, isHarness } from '../harness.js';
-import { checkInstall, fixBrokenMarkers } from './install.js';
+import { checkInstall, fixBrokenMarkers, legacyLine, removeLegacy } from './install.js';
 const PLAIN_SEMVER = /^\d+\.\d+\.\d+$/;
 const REGISTRY_TIMEOUT_MS = 3000;
 const NPM_PROBE_TIMEOUT_MS = 3000;
@@ -131,8 +131,8 @@ function devCheckoutStep(packageRoot) {
 }
 function readIntegration(home) {
     try {
-        const { skills, blocks } = checkInstall(home);
-        return { mode: blocks.length > 0 ? 'always-on' : 'invoke-only', blocks, skills };
+        const { skills, blocks, legacy } = checkInstall(home);
+        return { mode: blocks.length > 0 || legacy.length > 0 ? 'always-on' : 'invoke-only', blocks, skills, legacy };
     }
     catch {
         return null;
@@ -155,7 +155,18 @@ function integrationSteps(integration, upgrading, env) {
             text: fixBrokenMarkers(b.path, 'hafez upgrade'),
         }));
     }
-    const { blocks, skills } = integration;
+    const { blocks, skills, legacy } = integration;
+    // The 1.x section goes first: the always-on install writes a Block beside
+    // it, and both would be loaded.
+    const removals = legacy.map(l => ({ kind: 'action', text: removeLegacy(l.path, l.line) }));
+    const unblocked = legacy
+        .filter(l => !blocks.some(b => b.harness === l.harness))
+        .map(l => ({ kind: 'command', text: `hafez onboard --install --mode always-on --harness ${l.harness}` }));
+    // With no Block, the always-on install refreshes the skills too.
+    const rest = blocks.length === 0 && legacy.length > 0 ? [] : blockSteps(integration, upgrading, env);
+    return [...removals, ...unblocked, ...rest];
+}
+function blockSteps({ blocks, skills }, upgrading, env) {
     const skillDrift = skills.some(s => s.state === 'stale' || s.state === 'hand-edited');
     const blockDrift = (b) => b.state === 'stale' || (b.state === 'hand-edited' && b.renderChanged);
     const installed = blocks.length > 0 || skills.some(s => s.state !== 'absent');
@@ -263,13 +274,15 @@ function integrationLines(integration) {
     if (integration === null)
         return ['Skills and Block: could not be read.'];
     const lines = integration.mode === 'always-on'
-        ? ['Mode: always-on (a Block is installed).']
+        ? [integration.blocks.length > 0 ? 'Mode: always-on (a Block is installed).' : 'Mode: always-on (legacy: a Hafez 1.x section with no markers).']
         : [
             'Mode: invoke-only (no Block in any instructions file Hafez writes); installing a Block is not offered.',
             "A Block pasted into Cursor's User Rules lives in its Settings and is not checked here.",
         ];
     for (const b of integration.blocks)
         lines.push(`- Block in ${b.path}: ${BLOCK_STATE[b.state](b)}`);
+    for (const l of integration.legacy)
+        lines.push(`- ${legacyLine(l.path, l.line)}, from Hafez 1.x, with no markers`);
     for (const s of integration.skills) {
         const lost = s.state === 'hand-edited' ? ' — `onboard --install` replaces it, and the edit is lost' : '';
         lines.push(`- ${s.path}: ${s.state}${lost}`);

package/dist/contracts.js

@@ -195,6 +195,8 @@ export const WRITE_LINE_OMITS = {
         status: 'a lifecycle change, not a write-back: the `hafez` skill\'s rare ops carry the status line',
         agent: 'detected from the Harness; the override is never shown',
         add_action: 'the one-line form of add_actions, written by the same flag',
+        complete_actions: 'the repeated form of complete_action, written by the same flag',
+        remove_actions: 'the repeated form of remove_action, written by the same flag',
         clear_actions: 'drops lines unseen; the Footer drops one line by its Handle',
         description: SET_AT_CREATE,
         resource: SET_AT_CREATE,

package/dist/surfaces/items.js

@@ -116,6 +116,11 @@ const setOrCleared = (field, name = field.replace(/_/g, ' ')) => f => {
         return undefined;
     return value === null || value === '' || (Array.isArray(value) && value.length === 0) ? `${name} cleared` : `${name} set`;
 };
+/** `<n> action(s) <verb>` over a Next Actions field's one-line and array forms. */
+function countPhrase(one, many, verb) {
+    const n = (one !== undefined ? 1 : 0) + (many?.length ?? 0);
+    return n > 0 ? `${n} action${n === 1 ? '' : 's'} ${verb}` : undefined;
+}
 /** What each update field did, for the success line; `null` for a field that
  * changes nothing of its own. Keyed by every update field, so a new field
  * without a phrase fails the build. Key order is the line's order: the
@@ -123,12 +128,11 @@ const setOrCleared = (field, name = field.replace(/_/g, ' ')) => f => {
 const CHANGE_PHRASES = {
     session_log: (_f, r) => r.logged ? 'log added' : undefined,
     clear_actions: f => f.clear_actions ? 'actions cleared' : undefined,
-    complete_action: f => f.complete_action !== undefined ? '1 action ticked' : undefined,
-    remove_action: f => f.remove_action !== undefined ? '1 action removed' : undefined,
-    add_actions: f => {
-        const n = (f.add_action !== undefined ? 1 : 0) + (f.add_actions?.length ?? 0);
-        return n > 0 ? `${n} action${n === 1 ? '' : 's'} added` : undefined;
-    },
+    complete_action: f => countPhrase(f.complete_action, f.complete_actions, 'ticked'),
+    complete_actions: null, // counted with complete_action
+    remove_action: f => countPhrase(f.remove_action, f.remove_actions, 'removed'),
+    remove_actions: null, // counted with remove_action
+    add_actions: f => countPhrase(f.add_action, f.add_actions, 'added'),
     add_action: null, // counted with add_actions
     brief: setOrCleared('brief'),
     current_state: f => f.current_state !== undefined ? 'current state set' : undefined,

package/dist/types.d.ts

@@ -141,7 +141,9 @@ export interface UpdateFields {
     add_action?: string;
     add_actions?: string[];
     complete_action?: string;
+    complete_actions?: string[];
     remove_action?: string;
+    remove_actions?: string[];
     clear_actions?: boolean;
     parent?: string;
     description?: string | null;
@@ -158,6 +160,8 @@ export interface UpdateFields {
 export interface UpdateResult {
     completed_action?: string;
     removed_action?: string;
+    completed_actions?: string[];
+    removed_actions?: string[];
     logged?: true;
 }
 export interface CreateEntityFields {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hafez",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",