@agent-plan/core 0.2.19-next.2 → 0.2.19-next.21

package/dist/recap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recap.d.ts","sourceRoot":"","sources":["../src/recap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,KAAK,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,GAAE,YAAiB,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CA+GhH"}
+{"version":3,"file":"recap.d.ts","sourceRoot":"","sources":["../src/recap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,KAAK,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,GAAE,YAAiB,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgJhH"}

package/dist/recap.js

@@ -49,7 +49,6 @@ export async function buildRecap(st, web = {}, opts = {}) {
     const featureAddCmd = cmd("/planner feature add", "planner-feature-add");
     const phaseAddCmd = cmd("/planner phase add", "planner-phase-add");
     const handoffShowCmd = cmd("/planner handoff show", "planner-handoff-show");
-    const handoffClearCmd = cmd("/planner handoff clear", "planner-handoff-clear");
     const lines = [];
     lines.push(italian ? "## Ripresa planner" : "## Planner recap");
     const name = plan.project.name || "(unnamed project)";
@@ -63,6 +62,10 @@ export async function buildRecap(st, web = {}, opts = {}) {
         const tr = tref(focusTask.task.number);
         lines.push(`${italian ? "Focus corrente" : "Current focus"}: ${fr} — ${focusFeature?.name ?? "?"} / ${pr} — ${focusPhase.title} / ${tr} — ${focusTask.task.title} (in-progress)`);
     }
+    else if (handoffs.length > 0) {
+        const top = handoffs[0];
+        lines.push(`${italian ? "Focus corrente" : "Current focus"}: ${italian ? "nessun task attivo" : "no active task"} · ${italian ? "handoff pendente più recente" : "most recent pending handoff"}: ${top.compositeRef} — "${top.firstLine}"`);
+    }
     else if (planComplete) {
         lines.push(italian
             ? "Focus corrente: piano completo — tutte le feature/fasi/task sono concluse."
@@ -71,18 +74,41 @@ export async function buildRecap(st, web = {}, opts = {}) {
     else {
         lines.push(`${italian ? "Focus corrente" : "Current focus"}: ${italian ? "nessun task attivo — rivedi il piano e scegli il prossimo task concreto" : "no active task — review the plan and pick the next concrete task"}`);
     }
-    // Next step: only surface resume.nextSteps when the plan is NOT complete —
-    // otherwise stale init-time steps (e.g. "bootstrap discovery") leak through
-    // and contradict an all-done plan.
-    if (!planComplete && resume?.nextSteps?.length) {
+    // Next step: the phase handoff (phase.handoff) is the authoritative,
+    // actively-managed resume context. When a handoff is pending, point to it
+    // instead of surfacing potentially-stale resume.json nextSteps. When no
+    // handoff exists, fall back to resume.nextSteps but mark them as possibly
+    // stale (free-text that refreshResume never touches, so they can drift).
+    if (handoffs.length > 0) {
+        lines.push(italian
+            ? `Prossimo step: leggi l'handoff di fase pendente sotto (fonte autorevole, gestita attivamente). I nextSteps legacy di resume.json sono soppressi perché possono essere stale.`
+            : `Next step: read the pending phase handoff below (authoritative, actively maintained). Legacy resume.json nextSteps are suppressed because they may be stale.`);
+    }
+    else if (!planComplete && resume?.nextSteps?.length) {
         lines.push(`${italian ? "Prossimo step" : "Next step"}: ${resume.nextSteps[0]}`);
+        const staleNote = resume.nextStepsUpdatedAt
+            ? (italian
+                ? `⚠️ nextSteps free-text da resume.json, ultimo aggiornamento ${resume.nextStepsUpdatedAt} — può essere stale; verifica contro lo stato attuale prima di agire.`
+                : `⚠️ nextSteps are free-text from resume.json, last updated ${resume.nextStepsUpdatedAt} — may be stale; verify against current state before acting.`)
+            : (italian
+                ? `⚠️ nextSteps free-text da resume.json — può essere stale; verifica contro lo stato attuale prima di agire.`
+                : `⚠️ nextSteps are free-text from resume.json — may be stale; verify against current state before acting.`);
+        lines.push(staleNote);
     }
     if (handoffs.length > 0) {
+        const top = handoffs[0];
         lines.push("", italian ? `## Handoff di fase pendenti (${handoffs.length})` : `## Pending phase handoffs (${handoffs.length})`);
         handoffs.forEach((h, i) => lines.push(`[${i + 1}] ${h.compositeRef} — ${h.updatedAt} — "${h.firstLine}"`));
-        lines.push("", italian
-            ? `→ Leggi quello pertinente con ${handoffShowCmd} <ref> (valida contro lo stato attuale), poi ${handoffClearCmd} <ref> una volta consumato.`
-            : `→ Read the relevant one with ${handoffShowCmd} <ref> (validate against current state), then call ${handoffClearCmd} <ref> once consumed (delete-on-resume).`);
+        if (handoffs.length === 1) {
+            lines.push("", italian
+                ? `→ Vuoi riprendere da ${top.compositeRef}? Leggi l'handoff con ${handoffShowCmd} ${top.compositeRef} e avvia il primo task pertinente. L'handoff è MANTENUTO finché un task della fase non parte (auto-archiviato) o la fase non si conclude — non serve cancellarlo a mano.`
+                : `→ Do you want to resume from ${top.compositeRef}? Read the handoff with ${handoffShowCmd} ${top.compositeRef} and start the first relevant task. It is KEPT until a task in that phase starts (then auto-archived) or the phase completes — no need to clear it manually.`);
+        }
+        else {
+            lines.push("", italian
+                ? `→ Scegli da quale fase ripartire. Il più recente è [1] ${top.compositeRef} — leggilo con ${handoffShowCmd} ${top.compositeRef} e avvia il primo task pertinente. Ogni handoff è MANTENUTO finché un task della fase non parte (auto-archiviato) o la fase non si conclude — non serve cancellarlo a mano.`
+                : `→ Choose which phase to resume from. The most recent is [1] ${top.compositeRef} — read it with ${handoffShowCmd} ${top.compositeRef} and start the first relevant task. Each handoff is KEPT until a task in that phase starts (then auto-archived) or the phase completes — no need to clear it manually.`);
+        }
     }
     else if (planComplete) {
         lines.push("", italian
@@ -100,6 +126,6 @@ export async function buildRecap(st, web = {}, opts = {}) {
     else {
         lines.push("", italian ? "## Web UI" : "## Web UI", `🌐 Web UI: ${italian ? "non attiva — avvia con /planner load" : "not running — start with /planner load"}`);
     }
-    lines.push("", italian ? "Vuoi che riprendiamo da qui?" : "Do you want to resume from here?");
+    lines.push("", italian ? "Pronto a riprendere?" : "Ready to resume?");
     return lines.join("\n");
 }

package/dist/refs.d.ts

@@ -21,4 +21,27 @@ import type { Phase, Feature } from "./schema.js";
  * @param ref     the human-facing ref (P00x / P00x(F00x) / UUID / title)
  */
 export declare function findPhaseByRef(phases: Phase[], features: Feature[], ref: string): Phase | undefined;
+/**
+ * Resolve a task reference to { phase, task }. Harness-agnostic, shared by all
+ * adapters so resolution semantics are identical everywhere.
+ *
+ * Supported task refs (case-insensitive):
+ *   - UUID:     "bd6ed366-..."            -> task.id
+ *   - Short:    "T003" | "t3"             -> task.number (GLOBALLY unique under the
+ *                                           new global-sequence numbering; bare T00x
+ *                                           is unambiguous across all phases)
+ *   - Compos:   "F001/P002/T003"          -> feature/phase/task numbers with parent
+ *                "P002(F001)/T003"          validation (feature + phase must match)
+ *                "P002/T003"
+ *   - ShortId:  "UUXD1"                   -> task.shortId (5-char, globally unique)
+ *   - Title:    exact match, then includes (backward-compat fallback)
+ *
+ * Returns `undefined` when not found, or when a composite parent (phase/feature)
+ * does not match the resolved task's parent.
+ */
+import type { Task } from "./schema.js";
+export declare function findTaskByRef(phases: Phase[], features: Feature[], ref: string): {
+    phase: Phase;
+    task: Task;
+} | undefined;
 //# sourceMappingURL=refs.d.ts.map

package/dist/refs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../src/refs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAKlD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,KAAK,EAAE,EACf,QAAQ,EAAE,OAAO,EAAE,EACnB,GAAG,EAAE,MAAM,GACV,KAAK,GAAG,SAAS,CAgCnB"}
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../src/refs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAKlD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,KAAK,EAAE,EACf,QAAQ,EAAE,OAAO,EAAE,EACnB,GAAG,EAAE,MAAM,GACV,KAAK,GAAG,SAAS,CAgCnB;AACD;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAiBxC,wBAAgB,aAAa,CAC3B,MAAM,EAAE,KAAK,EAAE,EACf,QAAQ,EAAE,OAAO,EAAE,EACnB,GAAG,EAAE,MAAM,GACV;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GAAG,SAAS,CA2D1C"}

package/dist/refs.js

@@ -40,3 +40,84 @@ export function findPhaseByRef(phases, features, ref) {
     return (phases.find((p) => p.title.toLowerCase() === normalized) ??
         phases.find((p) => p.title.toLowerCase().includes(normalized)));
 }
+// Extract optional feature/phase/task numbers from a composite ref.
+// Accepts 1+ digits so "t3" == "t003". Numbers are GLOBAL (post-migration).
+function parseTaskComposite(ref) {
+    // Anchored patterns only: composite refs (F00x/P00x/T00x, P00x(F00x)/T00x,
+    // P00x/T00x) and bare T00x. A 5-char shortId (e.g. "HT23X") or a title never
+    // matches these because they are anchored to the WHOLE string.
+    const composite = ref.match(/^f0*(\d+)\/p0*(\d+)\/t0*(\d+)$/);
+    if (composite)
+        return { featureNum: parseInt(composite[1], 10), phaseNum: parseInt(composite[2], 10), taskNum: parseInt(composite[3], 10) };
+    const phaseTask = ref.match(/^p0*(\d+)(?:\(f0*(\d+)\))?\/t0*(\d+)$/);
+    if (phaseTask)
+        return { phaseNum: parseInt(phaseTask[1], 10), featureNum: phaseTask[2] ? parseInt(phaseTask[2], 10) : undefined, taskNum: parseInt(phaseTask[3], 10) };
+    const bare = ref.match(/^t0*(\d+)$/);
+    if (bare)
+        return { taskNum: parseInt(bare[1], 10) };
+    return {};
+}
+export function findTaskByRef(phases, features, ref) {
+    const normalized = ref.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    // 1. UUID (exact)
+    for (const phase of phases) {
+        const task = phase.tasks.find((t) => t.id.toLowerCase() === normalized);
+        if (task)
+            return { phase, task };
+    }
+    // 1b. ShortId (5-char) — check BEFORE composite so a shortId like "HT23X"
+    // or "T1234" is never misread as a numeric task ref (regexes are anchored now,
+    // but a 5-char ref can still look numeric). SHORT_ID_LENGTH is always 5.
+    if (normalized.length === 5) {
+        for (const phase of phases) {
+            const task = phase.tasks.find((t) => t.shortId && t.shortId.toLowerCase() === normalized);
+            if (task)
+                return { phase, task };
+        }
+    }
+    // 2. Composite / short ref with a T segment
+    const { featureNum, phaseNum, taskNum } = parseTaskComposite(normalized);
+    if (taskNum !== undefined) {
+        if (phaseNum !== undefined) {
+            // Composite: validate phase (and feature if present), then resolve task by number.
+            const phase = phases.find((p) => p.number === phaseNum);
+            if (!phase)
+                return undefined;
+            if (featureNum !== undefined) {
+                const feat = features.find((f) => f.number === featureNum);
+                if (!feat || phase.featureId !== feat.id)
+                    return undefined;
+            }
+            const task = phase.tasks.find((t) => t.number === taskNum);
+            if (task)
+                return { phase, task };
+            return undefined;
+        }
+        // Bare T00x — globally unique under the new numbering. Find the one task.
+        for (const phase of phases) {
+            const task = phase.tasks.find((t) => t.number === taskNum);
+            if (task)
+                return { phase, task };
+        }
+    }
+    // 3. ShortId (5-char)
+    for (const phase of phases) {
+        const task = phase.tasks.find((t) => t.shortId && t.shortId.toLowerCase() === normalized);
+        if (task)
+            return { phase, task };
+    }
+    // 4. Title fallback (backward compatibility)
+    for (const phase of phases) {
+        const exact = phase.tasks.find((t) => t.title.toLowerCase() === normalized);
+        if (exact)
+            return { phase, task: exact };
+    }
+    for (const phase of phases) {
+        const incl = phase.tasks.find((t) => t.title.toLowerCase().includes(normalized));
+        if (incl)
+            return { phase, task: incl };
+    }
+    return undefined;
+}