@zq-silk/yui 0.15.8 → 0.15.11

package/dist/storage/migrations/integrationContinuation.js

@@ -0,0 +1,104 @@
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { durableJobIdempotencyKey } from "../../job/durableJob.js";
+import { resolveProjectVerificationPlan, verificationPlanDigest, planBootstrapJobSteps, planL2JobSteps } from "../../verification/verificationPlan.js";
+/** Classify only known v19 Git conflicts. Manual strategy and CAS blockers
+ * keep their meaning. Never synthesize candidate/Job success or edit history. */
+export function migrateIntegrationContinuation(db) {
+    const rows = db.prepare("SELECT task_id, integration_id, payload FROM integration_attempts").all();
+    const update = db.prepare("UPDATE integration_attempts SET status = ?, payload = ? WHERE task_id = ? AND integration_id = ?");
+    for (const row of rows) {
+        const attempt = JSON.parse(row.payload);
+        if (attempt.schemaVersion !== 6)
+            continue;
+        const proven = migrateBoundFastForward(db, attempt);
+        if (proven !== undefined) {
+            update.run(proven.status, JSON.stringify(proven), row.task_id, row.integration_id);
+            continue;
+        }
+        if (attempt.status !== "blocked")
+            continue;
+        const source = attempt.source;
+        const summary = attempt.conflict?.summary;
+        if (typeof summary !== "string")
+            continue;
+        const ordinary = (source?.kind === "upstream" && source.strategy === "rebase"
+            && summary.startsWith("Upstream rebase conflicts"))
+            || (source?.kind === "work-item" && source.strategy === "merge"
+                && summary.startsWith("WorkItem merge conflicts"))
+            || (source?.kind === "work-item" && source.strategy === "cherry-pick"
+                && summary.startsWith(`WorkItem ${source.workItemId} commit `)
+                && summary.includes(" conflicts with "));
+        if (!ordinary)
+            continue;
+        update.run("conflicted", JSON.stringify({ ...attempt, status: "conflicted" }), row.task_id, row.integration_id);
+    }
+}
+/** v19 bound a Job only after successful source application. For FF, its
+ * exact checked head IS the immutable source result, so the existing records
+ * prove application without inventing a reflog action or a successful result.
+ * Other old source strategies need evidence not available in these DB records.
+ * Keep this interpretation at the migration boundary, never in runtime reads. */
+function migrateBoundFastForward(db, attempt) {
+    if (!["running", "validating"].includes(attempt.status) || attempt.jobId === undefined
+        || attempt.source.kind !== "work-item" || attempt.source.strategy !== "ff")
+        return;
+    const read = (sql, ...keys) => {
+        const row = db.prepare(sql).get(...keys);
+        return row === undefined ? undefined : JSON.parse(row.payload);
+    };
+    const task = read("SELECT payload FROM task_records WHERE task_id = ?", attempt.taskId);
+    const project = read("SELECT payload FROM projects WHERE id = ?", attempt.projectId);
+    const job = read("SELECT payload FROM durable_jobs WHERE task_id = ? AND job_id = ?", attempt.taskId, attempt.jobId);
+    const workspaces = db.prepare("SELECT payload FROM managed_workspaces WHERE task_id = ?").all(attempt.taskId)
+        .map(row => JSON.parse(row.payload));
+    const workspace = workspaces.find(w => w.owner.type === "integration-attempt"
+        && w.owner.taskId === attempt.taskId && w.owner.integrationAttemptId === attempt.id);
+    const main = workspaces.find(w => w.owner.type === "task" && w.owner.taskId === attempt.taskId);
+    const entry = workspace?.entries.find(e => e.projectId === attempt.projectId && e.access === "write");
+    const mainEntry = main?.entries.find(e => e.projectId === attempt.projectId && e.access === "write");
+    const binding = task?.projectBindings.find(b => b.projectId === attempt.projectId);
+    if (task?.id !== attempt.taskId || project?.id !== attempt.projectId || binding === undefined
+        || workspace === undefined || entry === undefined || mainEntry === undefined
+        || workspace.entries.length !== 1 || entry.path !== workspace.root
+        || entry.baseCommit !== attempt.beforeCommit
+        || job?.id !== attempt.jobId || job.taskId !== attempt.taskId
+        || job.owner.kind !== "integration-attempt" || job.owner.integrationAttemptId !== attempt.id
+        || job.projectId !== attempt.projectId || job.workspace !== workspace.root
+        || job.operation.targetId !== job.workspace
+        || job.head !== attempt.source.resultCommit
+        || (attempt.candidateCommit !== undefined && attempt.candidateCommit !== job.head)
+        || job.operation.inputDigest !== durableJobIdempotencyKey(job))
+        return;
+    let steps = attempt.checkCommands.map((command, index) => ({
+        name: `check-${index + 1}`, command, timeoutMs: 30 * 60_000
+    }));
+    if (attempt.gatePlanDigest !== undefined) {
+        const plan = resolveProjectVerificationPlan(project);
+        if (plan === undefined || verificationPlanDigest(plan) !== attempt.gatePlanDigest)
+            return;
+        steps = [...planBootstrapJobSteps(plan), ...planL2JobSteps(plan)].map(step => ({
+            ...step, timeoutMs: 30 * 60_000
+        }));
+    }
+    const inputDigest = durableJobIdempotencyKey(job);
+    if (inputDigest !== durableJobIdempotencyKey({ ...job, steps }))
+        return;
+    const branch = entry.branch;
+    return {
+        ...attempt,
+        candidateCommit: job.head,
+        checkInputDigest: inputDigest,
+        sourceProgress: {
+            workspace: resolve(workspace.root), branch: fullRef(branch), head: job.head,
+            completedSteps: 1,
+            sourceDigest: createHash("sha256").update(JSON.stringify([
+                attempt.taskId, attempt.id, attempt.projectId, attempt.targetRef,
+                attempt.beforeCommit, attempt.source, resolve(workspace.root), branch
+            ])).digest("hex")
+        }
+    };
+}
+function fullRef(branch) {
+    return branch.startsWith("refs/") ? branch : `refs/heads/${branch}`;
+}

package/dist/storage/migrations/submitIntent.js

@@ -0,0 +1,126 @@
+import { createTaskEvent } from "../../event/taskEvent.js";
+/**
+ * Storage 18 -> 19 data step for task-32 Requirement A (submit intent & Draft
+ * auto-routing).
+ *
+ * This helper is INDEPENDENT, deterministic and idempotent. The unified 18 -> 19
+ * migration owned by the artifacts WorkItem REGISTERS it (as its `migrateData`)
+ * and bumps `CURRENT_STORAGE_VERSION`; this module neither registers a second
+ * migration nor changes any schema.
+ *
+ * Requirement A adds three optional fields inside `messages.payload`, all part of
+ * this same 18 -> 19 contract even though each is optional — "optional" governs a
+ * single record's shape, not the Home compatibility line, so the version
+ * transition is still declared here and carried by the unified migration:
+ *
+ *  - `intent` (record | discuss | develop): an absent value already reads as
+ *    `discuss` (never `develop`), so historical Messages need no rewrite.
+ *  - `submissionKey`: the client-chosen idempotency key. Only ever set going
+ *    forward; NO historical key is fabricated (task-32 §2.3, message review), so
+ *    old Messages stay keyless and non-idempotent exactly as before.
+ *  - `submissionReceipt`: the frozen disposition a keyed submission replays from.
+ *    Written only alongside a new `submissionKey`, so it too never appears on
+ *    historical data.
+ *
+ * Because none of the three needs a value backfilled onto old rows, the only data
+ * step this migration performs is the planning-entered reconstruction below.
+ *
+ * The one fact old data cannot express is "this Draft already entered planning".
+ * Before Requirement A a Leader-waking user/operator submission on a Draft WAS
+ * the planning discussion, but it left no `task.planning-entered` fact because
+ * that event type did not exist. After the upgrade `develop` auto-activates an
+ * *unplanned* Draft; without this step a Draft that was mid-discussion would be
+ * mis-read as unplanned and snatched into auto-activation (task-32 §2.2, §4).
+ *
+ * So for every Draft that received at least one legitimate historical planning
+ * submission this appends exactly one `task.planning-entered` event, which makes
+ * {@link draftHasEnteredPlanning} derive `true` and routes a later develop to
+ * manual activation. A qualifying submission is an *unaddressed* user/operator
+ * Message that was not save-only (`wakePolicy !== "none"`) — byte-for-byte the
+ * same shape the new discuss path routes through the shared submission service.
+ *
+ * This is deliberately the conservative direction: it can only ever make develop
+ * MORE cautious, never activate a Draft it should not. Save-only Messages (old
+ * `wakePolicy === "none"`, the shape `record` now names) are excluded, so a Draft
+ * that only ever recorded context stays legitimately unplanned and its first
+ * develop may still auto-activate. Non-Draft Tasks are skipped because
+ * {@link draftHasEnteredPlanning} answers only about Drafts, and Activation
+ * requests are left untouched — a legacy request's absent `origin` is the
+ * truthful marker that it stays behind explicit activation.
+ */
+export function migrateSubmitIntent(db) {
+    const drafts = db.prepare("SELECT task_id FROM tasks_catalog WHERE status = 'draft'").all();
+    if (drafts.length === 0)
+        return;
+    const listMessages = db.prepare("SELECT payload FROM messages WHERE task_id = ? ORDER BY seq ASC");
+    const listEventRows = db.prepare("SELECT event_id, type FROM events WHERE task_id = ?");
+    const readHighWater = db.prepare("SELECT high_water FROM id_sequences WHERE task_id = ? AND kind = 'event'");
+    // Advance the per-Task event high-water to exactly the id we just consumed, so
+    // the runtime keeps allocating strictly above every migrated event (mirrors
+    // sqliteStore's id_sequences bookkeeping).
+    const upsertHighWater = db.prepare(`INSERT INTO id_sequences (task_id, kind, high_water) VALUES (?, 'event', ?)
+     ON CONFLICT(task_id, kind) DO UPDATE SET high_water = ?`);
+    const insertEvent = db.prepare("INSERT INTO events (task_id, event_id, type, occurred_at, payload) VALUES (?, ?, ?, ?, ?)");
+    for (const { task_id: taskId } of drafts) {
+        const eventRows = listEventRows.all(taskId);
+        // Idempotent: a Draft that already carries the fact (from a prior run of this
+        // migration, or from a real runtime planning entry) is left untouched.
+        if (eventRows.some((row) => row.type === PLANNING_ENTERED_EVENT_TYPE))
+            continue;
+        const entry = firstPlanningSubmission(listMessages.all(taskId));
+        if (entry === undefined)
+            continue;
+        // Allocate the next event id from the greater of the recorded high-water and
+        // the largest event id actually present, so a fixture or historical database
+        // whose id_sequences lags the events table can never produce a colliding id.
+        const highWater = readHighWater.get(taskId)?.high_water ?? 0;
+        const maxEventSeq = eventRows.reduce((max, row) => Math.max(max, eventSequence(row.event_id)), 0);
+        const seq = Math.max(highWater, maxEventSeq) + 1;
+        // Build through the shared constructor so a migrated event is byte-identical
+        // in shape to one the shared submission service writes at runtime, and dated
+        // to the historical submission rather than the wall-clock upgrade moment.
+        const event = createTaskEvent(`event-${seq}`, taskId, PLANNING_ENTERED_EVENT_TYPE, { messageId: entry.id, intent: "discuss", derivedBy: MIGRATION_PROVENANCE }, new Date(entry.createdAt));
+        insertEvent.run(taskId, event.id, event.type, event.createdAt, JSON.stringify(event));
+        upsertHighWater.run(taskId, seq, seq);
+    }
+}
+/**
+ * The never-compacted event type recording a Draft entered planning. Inlined as a
+ * literal rather than imported so this released migration stays frozen against a
+ * future runtime rename of the constant; `TASK_PLANNING_ENTERED_EVENT` is the
+ * runtime owner, and a tripwire test asserts the two never diverge.
+ */
+const PLANNING_ENTERED_EVENT_TYPE = "task.planning-entered";
+/** Marks the event as reconstructed by this migration, for later audit. */
+const MIGRATION_PROVENANCE = "submit-intent-migration";
+/**
+ * The earliest Message on a Draft that represents a historical planning
+ * submission, or `undefined` if the Draft only ever recorded save-only context.
+ *
+ * A qualifying Message is an unaddressed (`recipient === undefined`) user or
+ * operator Message whose wake policy was not `none`. An absent wake policy
+ * qualifies: before Requirement A that was the default Leader-waking submission,
+ * exactly the shape an omitted intent normalizes to `discuss` today.
+ */
+function firstPlanningSubmission(rows) {
+    for (const row of rows) {
+        const message = JSON.parse(row.payload);
+        if (message.kind !== "user" && message.kind !== "operator")
+            continue;
+        if (message.recipient !== undefined)
+            continue; // an addressed continuation, not a submission
+        if (message.wakePolicy === "none")
+            continue; // old save-only == record, never planning
+        if (typeof message.id !== "string")
+            continue;
+        if (typeof message.createdAt !== "string")
+            continue;
+        return { id: message.id, createdAt: message.createdAt };
+    }
+    return undefined;
+}
+/** The numeric suffix of an `event-<n>` id, or 0 for any unexpected shape. */
+function eventSequence(eventId) {
+    const match = /^event-(\d+)$/.exec(eventId);
+    return match === null ? 0 : Number.parseInt(match[1], 10);
+}