cclaw-cli 0.5.4 → 0.5.5

package/dist/runs.js

@@ -6,8 +6,6 @@ import { ensureDir, exists, withDirectoryLock, writeFileSafe } from "./fs-utils.
 const FLOW_STATE_REL_PATH = `${RUNTIME_ROOT}/state/flow-state.json`;
 const RUNS_DIR_REL_PATH = `${RUNTIME_ROOT}/runs`;
 const ACTIVE_ARTIFACTS_REL_PATH = `${RUNTIME_ROOT}/artifacts`;
-const RUN_META_FILE = "run.json";
-const RUN_HANDOFF_FILE = "handoff.md";
 const FLOW_STAGE_SET = new Set(COMMAND_FILE_ORDER);
 function flowStatePath(projectRoot) {
     return path.join(projectRoot, FLOW_STATE_REL_PATH);
@@ -21,65 +19,6 @@ function runsRoot(projectRoot) {
 function activeArtifactsPath(projectRoot) {
     return path.join(projectRoot, ACTIVE_ARTIFACTS_REL_PATH);
 }
-function runRoot(projectRoot, runId) {
-    return path.join(runsRoot(projectRoot), requireSafeRunId(runId));
-}
-function runArtifactsPath(projectRoot, runId) {
-    return path.join(runRoot(projectRoot, runId), "artifacts");
-}
-function runMetaPath(projectRoot, runId) {
-    return path.join(runRoot(projectRoot, runId), RUN_META_FILE);
-}
-function runHandoffPath(projectRoot, runId) {
-    return path.join(runRoot(projectRoot, runId), RUN_HANDOFF_FILE);
-}
-function nowIso() {
-    return new Date().toISOString();
-}
-function pad2(value) {
-    return value.toString().padStart(2, "0");
-}
-function buildRunId(date = new Date()) {
-    const yyyy = date.getUTCFullYear();
-    const mm = pad2(date.getUTCMonth() + 1);
-    const dd = pad2(date.getUTCDate());
-    const hh = pad2(date.getUTCHours());
-    const min = pad2(date.getUTCMinutes());
-    const ss = pad2(date.getUTCSeconds());
-    const random = Math.random().toString(36).slice(2, 6);
-    return `run-${yyyy}${mm}${dd}-${hh}${min}${ss}-${random}`;
-}
-function normalizeTitle(title) {
-    const trimmed = (title ?? "").trim();
-    if (trimmed.length === 0) {
-        return "New feature run";
-    }
-    return trimmed;
-}
-function isSafeRunId(value) {
-    return /^[A-Za-z0-9_-]{1,128}$/u.test(value);
-}
-function sanitizeRunId(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    return isSafeRunId(trimmed) ? trimmed : undefined;
-}
-function requireSafeRunId(runId) {
-    const safe = sanitizeRunId(runId);
-    if (!safe) {
-        throw new Error(`Invalid run id "${runId}"`);
-    }
-    return safe;
-}
-function snapshotState(state) {
-    return {
-        currentStage: state.currentStage,
-        completedStages: [...state.completedStages],
-        guardEvidence: { ...state.guardEvidence },
-        stageGateCatalog: JSON.parse(JSON.stringify(state.stageGateCatalog))
-    };
-}
 function isFlowStage(value) {
     return typeof value === "string" && FLOW_STAGE_SET.has(value);
 }
@@ -144,300 +83,148 @@ function sanitizeStageGateCatalog(value, fallback) {
     }
     return next;
 }
-function coerceFlowState(parsed, activeRunIdOverride) {
-    const overrideTrim = sanitizeRunId(activeRunIdOverride);
-    const parsedActiveRun = sanitizeRunId(parsed.activeRunId);
-    const seedRunId = overrideTrim ?? parsedActiveRun;
-    const next = createInitialFlowState(seedRunId);
+function coerceFlowState(parsed) {
+    const next = createInitialFlowState();
+    const activeRunIdRaw = parsed.activeRunId;
+    const activeRunId = typeof activeRunIdRaw === "string" && activeRunIdRaw.trim().length > 0
+        ? activeRunIdRaw.trim()
+        : next.activeRunId;
     return {
-        activeRunId: overrideTrim ?? parsedActiveRun ?? next.activeRunId,
+        activeRunId,
         currentStage: isFlowStage(parsed.currentStage) ? parsed.currentStage : next.currentStage,
         completedStages: sanitizeCompletedStages(parsed.completedStages),
         guardEvidence: sanitizeGuardEvidence(parsed.guardEvidence),
         stageGateCatalog: sanitizeStageGateCatalog(parsed.stageGateCatalog, next.stageGateCatalog)
     };
 }
-function createdAtFromRunId(runId) {
-    const match = /^run-(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})-[a-z0-9]+$/iu.exec(runId);
-    if (!match) {
-        return null;
+function toArchiveDate(date = new Date()) {
+    const yyyy = date.getFullYear().toString();
+    const mm = (date.getMonth() + 1).toString().padStart(2, "0");
+    const dd = date.getDate().toString().padStart(2, "0");
+    return `${yyyy}-${mm}-${dd}`;
+}
+function slugifyFeatureName(value) {
+    const slug = value
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/gu, "-")
+        .replace(/^-+/u, "")
+        .replace(/-+$/u, "");
+    if (slug.length === 0) {
+        return "feature";
+    }
+    return slug.slice(0, 64);
+}
+async function inferFeatureNameFromArtifacts(projectRoot) {
+    const ideaPath = path.join(projectRoot, ACTIVE_ARTIFACTS_REL_PATH, "00-idea.md");
+    if (!(await exists(ideaPath))) {
+        return "feature";
     }
-    const [, year, month, day, hour, minute, second] = match;
-    const date = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second)));
-    return Number.isNaN(date.getTime()) ? null : date.toISOString();
-}
-async function readJsonFile(filePath) {
-    if (!(await exists(filePath)))
-        return null;
     try {
-        return JSON.parse(await fs.readFile(filePath, "utf8"));
+        const raw = await fs.readFile(ideaPath, "utf8");
+        const firstMeaningful = raw
+            .split(/\r?\n/gu)
+            .map((line) => line.trim())
+            .find((line) => line.length > 0);
+        if (!firstMeaningful) {
+            return "feature";
+        }
+        return firstMeaningful.replace(/^[-#*\s]+/u, "").trim() || "feature";
     }
     catch {
-        return null;
+        return "feature";
     }
 }
-async function listImmediateFiles(dirPath) {
-    if (!(await exists(dirPath)))
-        return [];
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    return entries.filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
-}
-async function clearImmediateFiles(dirPath) {
-    if (!(await exists(dirPath)))
-        return;
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.isFile()) {
-            await fs.rm(path.join(dirPath, entry.name), { force: true });
-        }
+async function uniqueArchiveId(projectRoot, baseId) {
+    let index = 1;
+    let candidate = baseId;
+    while (await exists(path.join(runsRoot(projectRoot), candidate))) {
+        index += 1;
+        candidate = `${baseId}-${index}`;
     }
-}
-async function copyImmediateFiles(fromDir, toDir) {
-    await ensureDir(toDir);
-    const fileNames = await listImmediateFiles(fromDir);
-    for (const fileName of fileNames) {
-        const sourcePath = path.join(fromDir, fileName);
-        const targetPath = path.join(toDir, fileName);
-        await fs.copyFile(sourcePath, targetPath);
-    }
-}
-function handoffMarkdown(runMeta, state) {
-    return `# Run Handoff
-
-## Run
-- ID: ${runMeta.id}
-- Title: ${runMeta.title}
-- Created: ${runMeta.createdAt}
-- Archived: ${runMeta.archivedAt ?? "active"}
-
-## Flow Snapshot
-- Active stage: ${state.currentStage}
-- Completed stages: ${state.completedStages.join(", ") || "(none)"}
-- Active run ID in flow-state: ${state.activeRunId}
-
-## Paths
-- Active artifacts: \`${RUNTIME_ROOT}/artifacts/\`
-- Canonical run artifacts: \`${RUNTIME_ROOT}/runs/${runMeta.id}/artifacts/\`
-
-## Resume
-1. Continue with the stage command for \`${state.currentStage}\`
-2. If needed, sync artifacts from \`${RUNTIME_ROOT}/runs/${runMeta.id}/artifacts/\`
-`;
+    return candidate;
 }
 export async function readFlowState(projectRoot) {
     const statePath = flowStatePath(projectRoot);
-    const parsed = await readJsonFile(statePath);
-    if (!parsed || typeof parsed !== "object") {
+    if (!(await exists(statePath))) {
+        return createInitialFlowState();
+    }
+    try {
+        const parsed = JSON.parse(await fs.readFile(statePath, "utf8"));
+        return coerceFlowState(parsed);
+    }
+    catch {
         return createInitialFlowState();
     }
-    return coerceFlowState(parsed);
 }
 export async function writeFlowState(projectRoot, state) {
     await withDirectoryLock(flowStateLockPath(projectRoot), async () => {
-        const safe = coerceFlowState({ ...state }, state.activeRunId);
+        const safe = coerceFlowState({ ...state });
         await writeFileSafe(flowStatePath(projectRoot), `${JSON.stringify(safe, null, 2)}\n`);
     });
 }
+export async function ensureRunSystem(projectRoot, _options = {}) {
+    await ensureDir(runsRoot(projectRoot));
+    await ensureDir(activeArtifactsPath(projectRoot));
+    const statePath = flowStatePath(projectRoot);
+    const state = await readFlowState(projectRoot);
+    if (!(await exists(statePath))) {
+        await writeFlowState(projectRoot, state);
+    }
+    return state;
+}
 export async function listRuns(projectRoot) {
     const root = runsRoot(projectRoot);
-    if (!(await exists(root)))
+    if (!(await exists(root))) {
         return [];
-    const dirs = await fs.readdir(root, { withFileTypes: true });
-    const metas = [];
-    for (const dir of dirs) {
-        if (!dir.isDirectory())
-            continue;
-        const runId = dir.name;
-        if (!isSafeRunId(runId))
-            continue;
-        const meta = await readJsonFile(runMetaPath(projectRoot, runId));
-        if (meta && typeof meta.id === "string" && meta.id === runId) {
-            metas.push(meta);
+    }
+    const entries = await fs.readdir(root, { withFileTypes: true });
+    const runs = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
             continue;
         }
-        let fallbackCreatedAt = createdAtFromRunId(runId);
-        if (!fallbackCreatedAt) {
-            try {
-                const stat = await fs.stat(path.join(root, runId));
-                fallbackCreatedAt = stat.birthtime?.toISOString?.() ?? stat.mtime.toISOString();
-            }
-            catch {
-                fallbackCreatedAt = null;
-            }
+        const runPath = path.join(root, entry.name);
+        let createdAt = new Date().toISOString();
+        try {
+            const stat = await fs.stat(runPath);
+            createdAt = stat.birthtime?.toISOString?.() ?? stat.mtime.toISOString();
         }
-        metas.push({
-            id: runId,
-            title: runId,
-            createdAt: fallbackCreatedAt ?? nowIso()
-        });
-    }
-    return metas.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-}
-async function ensureRunMetadata(projectRoot, meta) {
-    await writeFileSafe(runMetaPath(projectRoot, meta.id), `${JSON.stringify(meta, null, 2)}\n`);
-}
-async function persistRunStateSnapshot(projectRoot, runId, state) {
-    const meta = await readJsonFile(runMetaPath(projectRoot, runId));
-    if (!meta)
-        return;
-    const safeState = coerceFlowState({ ...state }, state.activeRunId);
-    await ensureRunMetadata(projectRoot, {
-        ...meta,
-        stateSnapshot: snapshotState(safeState)
-    });
-}
-async function syncActiveArtifactsToRun(projectRoot, runId) {
-    const fromDir = activeArtifactsPath(projectRoot);
-    const toDir = runArtifactsPath(projectRoot, runId);
-    await ensureDir(toDir);
-    await clearImmediateFiles(toDir);
-    await copyImmediateFiles(fromDir, toDir);
-}
-async function loadRunArtifactsToActive(projectRoot, runId) {
-    const fromDir = runArtifactsPath(projectRoot, runId);
-    const toDir = activeArtifactsPath(projectRoot);
-    await ensureDir(toDir);
-    await clearImmediateFiles(toDir);
-    await copyImmediateFiles(fromDir, toDir);
-}
-async function createRun(projectRoot, options) {
-    const runId = buildRunId();
-    const meta = {
-        id: runId,
-        title: normalizeTitle(options?.title),
-        createdAt: nowIso()
-    };
-    await ensureDir(runRoot(projectRoot, runId));
-    await ensureRunMetadata(projectRoot, meta);
-    const runArtifactsDir = runArtifactsPath(projectRoot, runId);
-    await ensureDir(runArtifactsDir);
-    if (options?.seedFromActiveArtifacts && (await exists(activeArtifactsPath(projectRoot)))) {
-        await copyImmediateFiles(activeArtifactsPath(projectRoot), runArtifactsDir);
-    }
-    return meta;
-}
-async function ensureRunHandoff(projectRoot, runId) {
-    const state = await readFlowState(projectRoot);
-    const meta = await readJsonFile(runMetaPath(projectRoot, runId));
-    if (!meta)
-        return;
-    await writeFileSafe(runHandoffPath(projectRoot, runId), handoffMarkdown(meta, state));
-}
-export async function ensureRunSystem(projectRoot, options = {}) {
-    await ensureDir(runsRoot(projectRoot));
-    await ensureDir(activeArtifactsPath(projectRoot));
-    let state = await readFlowState(projectRoot);
-    let activeRunId = state.activeRunId;
-    const createIfMissing = options.createIfMissing !== false;
-    const activeRunExists = activeRunId.trim().length > 0 && (await exists(runArtifactsPath(projectRoot, activeRunId)));
-    if (!activeRunExists) {
-        if (!createIfMissing) {
-            return state;
+        catch {
+            // keep fallback timestamp
         }
-        const activeHasArtifacts = (await listImmediateFiles(activeArtifactsPath(projectRoot))).length > 0;
-        const initialRun = await createRun(projectRoot, {
-            title: activeHasArtifacts ? "Migrated active run" : "Initial feature run",
-            seedFromActiveArtifacts: activeHasArtifacts
+        runs.push({
+            id: entry.name,
+            title: entry.name,
+            createdAt
         });
-        activeRunId = initialRun.id;
-        state = { ...state, activeRunId };
-        await writeFlowState(projectRoot, state);
-    }
-    const runArtifactsDir = runArtifactsPath(projectRoot, activeRunId);
-    await ensureDir(runArtifactsDir);
-    if ((await listImmediateFiles(activeArtifactsPath(projectRoot))).length === 0) {
-        await loadRunArtifactsToActive(projectRoot, activeRunId);
     }
-    else {
-        await syncActiveArtifactsToRun(projectRoot, activeRunId);
-    }
-    await persistRunStateSnapshot(projectRoot, activeRunId, state);
-    await ensureRunHandoff(projectRoot, activeRunId);
-    return state;
-}
-export async function startNewFeatureRun(projectRoot, title) {
-    await ensureRunSystem(projectRoot);
-    const state = await readFlowState(projectRoot);
-    await syncActiveArtifactsToRun(projectRoot, state.activeRunId);
-    await persistRunStateSnapshot(projectRoot, state.activeRunId, state);
-    await ensureRunHandoff(projectRoot, state.activeRunId);
-    const nextRun = await createRun(projectRoot, {
-        title,
-        seedFromActiveArtifacts: false
-    });
-    const nextState = {
-        ...createInitialFlowState(nextRun.id),
-        activeRunId: nextRun.id
-    };
-    await writeFlowState(projectRoot, nextState);
-    await persistRunStateSnapshot(projectRoot, nextRun.id, nextState);
-    await loadRunArtifactsToActive(projectRoot, nextRun.id);
-    await ensureRunHandoff(projectRoot, nextRun.id);
-    return nextRun;
+    return runs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
-export async function resumeRun(projectRoot, runId) {
+export async function archiveRun(projectRoot, featureName) {
     await ensureRunSystem(projectRoot);
-    const safeRunId = requireSafeRunId(runId);
-    const targetMeta = await readJsonFile(runMetaPath(projectRoot, safeRunId));
-    if (!targetMeta) {
-        throw new Error(`Run "${safeRunId}" not found under ${RUNTIME_ROOT}/runs/`);
-    }
-    const state = await readFlowState(projectRoot);
-    await syncActiveArtifactsToRun(projectRoot, state.activeRunId);
-    await persistRunStateSnapshot(projectRoot, state.activeRunId, state);
-    await ensureRunHandoff(projectRoot, state.activeRunId);
-    const nextState = targetMeta.stateSnapshot
-        ? coerceFlowState({
-            ...createInitialFlowState(safeRunId),
-            ...targetMeta.stateSnapshot,
-            activeRunId: safeRunId
-        }, safeRunId)
-        : coerceFlowState({
-            ...createInitialFlowState(safeRunId),
-            activeRunId: safeRunId
-        }, safeRunId);
-    await writeFlowState(projectRoot, nextState);
-    await persistRunStateSnapshot(projectRoot, safeRunId, nextState);
-    await loadRunArtifactsToActive(projectRoot, safeRunId);
-    await ensureRunHandoff(projectRoot, safeRunId);
-    return targetMeta;
-}
-export async function archiveRun(projectRoot, runId) {
-    await ensureRunSystem(projectRoot);
-    const state = await readFlowState(projectRoot);
-    const targetRunId = runId ? requireSafeRunId(runId) : state.activeRunId;
-    const targetMeta = await readJsonFile(runMetaPath(projectRoot, targetRunId));
-    if (!targetMeta) {
-        throw new Error(`Run "${targetRunId}" not found under ${RUNTIME_ROOT}/runs/`);
-    }
-    if (targetRunId === state.activeRunId) {
-        await syncActiveArtifactsToRun(projectRoot, targetRunId);
-        await persistRunStateSnapshot(projectRoot, targetRunId, state);
-    }
-    const archivedMeta = {
-        ...targetMeta,
-        archivedAt: nowIso()
-    };
-    await ensureRunMetadata(projectRoot, archivedMeta);
-    await ensureRunHandoff(projectRoot, targetRunId);
-    if (targetRunId !== state.activeRunId) {
-        const activeMeta = await readJsonFile(runMetaPath(projectRoot, state.activeRunId));
-        if (!activeMeta) {
-            throw new Error(`Active run "${state.activeRunId}" is missing metadata`);
-        }
-        return { archived: archivedMeta, active: activeMeta };
-    }
-    const nextRun = await createRun(projectRoot, {
-        title: "Post-archive run",
-        seedFromActiveArtifacts: false
-    });
-    const nextState = {
-        ...createInitialFlowState(nextRun.id),
-        activeRunId: nextRun.id
+    const artifactsDir = activeArtifactsPath(projectRoot);
+    const runsDir = runsRoot(projectRoot);
+    await ensureDir(runsDir);
+    await ensureDir(artifactsDir);
+    const feature = (featureName?.trim() && featureName.trim().length > 0)
+        ? featureName.trim()
+        : await inferFeatureNameFromArtifacts(projectRoot);
+    const archiveBaseId = `${toArchiveDate()}-${slugifyFeatureName(feature)}`;
+    const archiveId = await uniqueArchiveId(projectRoot, archiveBaseId);
+    const archivePath = path.join(runsDir, archiveId);
+    const archiveArtifactsPath = path.join(archivePath, "artifacts");
+    await ensureDir(archivePath);
+    await fs.rename(artifactsDir, archiveArtifactsPath);
+    await ensureDir(artifactsDir);
+    const resetState = createInitialFlowState();
+    await writeFlowState(projectRoot, resetState);
+    const archivedAt = new Date().toISOString();
+    return {
+        archiveId,
+        archivePath,
+        archivedAt,
+        featureName: feature,
+        resetState
     };
-    await writeFlowState(projectRoot, nextState);
-    await persistRunStateSnapshot(projectRoot, nextRun.id, nextState);
-    await loadRunArtifactsToActive(projectRoot, nextRun.id);
-    await ensureRunHandoff(projectRoot, nextRun.id);
-    return { archived: archivedMeta, active: nextRun };
 }

package/dist/trace-matrix.js

@@ -2,22 +2,13 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
 import { exists } from "./fs-utils.js";
-import { readFlowState } from "./runs.js";
 function activeArtifactPath(projectRoot, name) {
     return path.join(projectRoot, RUNTIME_ROOT, "artifacts", name);
 }
-function canonicalRunArtifactPath(projectRoot, runId, name) {
-    return path.join(projectRoot, RUNTIME_ROOT, "runs", runId, "artifacts", name);
-}
-async function readArtifact(projectRoot, name, activeRunId) {
-    const runId = activeRunId.trim();
-    const candidates = runId.length > 0
-        ? [canonicalRunArtifactPath(projectRoot, runId, name), activeArtifactPath(projectRoot, name)]
-        : [activeArtifactPath(projectRoot, name)];
-    for (const candidate of candidates) {
-        if (await exists(candidate)) {
-            return fs.readFile(candidate, "utf8");
-        }
+async function readArtifact(projectRoot, name) {
+    const candidate = activeArtifactPath(projectRoot, name);
+    if (await exists(candidate)) {
+        return fs.readFile(candidate, "utf8");
     }
     return null;
 }
@@ -120,11 +111,10 @@ function layer1LinesForCriterion(layer1, criterionId) {
     return out;
 }
 export async function buildTraceMatrix(projectRoot) {
-    const { activeRunId } = await readFlowState(projectRoot);
-    const spec = await readArtifact(projectRoot, "04-spec.md", activeRunId);
-    const plan = await readArtifact(projectRoot, "05-plan.md", activeRunId);
-    const tdd = await readArtifact(projectRoot, "06-tdd.md", activeRunId);
-    const review = await readArtifact(projectRoot, "07-review.md", activeRunId);
+    const spec = await readArtifact(projectRoot, "04-spec.md");
+    const plan = await readArtifact(projectRoot, "05-plan.md");
+    const tdd = await readArtifact(projectRoot, "06-tdd.md");
+    const review = await readArtifact(projectRoot, "07-review.md");
     const criterionIds = spec ? parseAcceptanceCriterionIds(spec) : [];
     const taskToAcs = plan ? parsePlanTaskAcLinks(plan) : new Map();
     const allTaskIds = plan ? parsePlanTaskIds(plan) : [];

package/dist/types.d.ts

@@ -8,10 +8,6 @@ export interface VibyConfig {
     harnesses: HarnessId[];
     /** When true, stage skills instruct the agent to continue to the following stage after gates pass. */
     autoAdvance?: boolean;
-    /** Merge project bootstrap learnings with a global learnings file. */
-    globalLearnings?: boolean;
-    /** Optional absolute or project-relative path to global learnings JSONL. */
-    globalLearningsPath?: string;
     /** Prompt guard behavior for runtime write-risk detection hooks. */
     promptGuardMode?: "advisory" | "strict";
     /** When true, cclaw installs managed git pre-commit/pre-push wrappers. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {

package/dist/learnings-summarizer.d.ts

@@ -1,25 +0,0 @@
-export interface ObservationRecord {
-    ts?: string;
-    event?: string;
-    tool?: string;
-    phase?: string;
-    stage?: string;
-    runId?: string;
-    data?: unknown;
-}
-export type LearningSource = "observed" | "user-stated" | "inferred";
-export type LearningType = "pitfall" | "pattern" | "preference";
-export interface LearningRecord {
-    ts: string;
-    skill: string;
-    type: LearningType;
-    key: string;
-    insight: string;
-    confidence: number;
-    source: LearningSource;
-}
-export interface SummarizeOutcome {
-    candidates: LearningRecord[];
-    appendable: LearningRecord[];
-}
-export declare function summarizeObservationLearnings(observationJsonl: string, existingLearningsJsonl: string, timestamp: string): SummarizeOutcome;