agent-sdd 1.0.3

package/dist/features/record/application/AddRecord.js

@@ -0,0 +1,84 @@
+import { findMatches } from "../../../shared/domain/SpecApprovalRewrite.js";
+import { lintRecordsFromMarkdown } from "../../../shared/domain/SpecRecord.js";
+import { inspectBody, normalizeBody } from "../domain/RecordBody.js";
+import { isProtectedStatus, } from "../domain/RecordWrite.js";
+export async function addRecord(cwd, afterId, rawBody, ports) {
+    const body = normalizeBody(rawBody);
+    const facts = inspectBody(body);
+    if (facts.id === null) {
+        return invalid("body has no id or does not parse as YAML");
+    }
+    if (isProtectedStatus(facts.status)) {
+        return governed(`refusing to add a record with lifecycle.status ${facts.status}; add as draft/proposed`);
+    }
+    const config = await ports.config.config(cwd);
+    const entries = await ports.files.resolveSpecFiles(cwd, config.lint.specFiles);
+    for (const entry of entries) {
+        if (lintRecordsFromMarkdown(entry.path, entry.content).some((r) => r.id === facts.id)) {
+            return duplicate(`id already exists: ${facts.id}`);
+        }
+    }
+    const anchors = locate(entries, afterId);
+    if (anchors.length === 0) {
+        return notFound(`anchor not found: ${afterId}`);
+    }
+    if (anchors.length > 1) {
+        return ambiguous(`anchor id is ambiguous: ${afterId} matches ${anchors.length} records`);
+    }
+    const anchor = anchors[0];
+    const lines = anchor.entry.content.split(/\r?\n/);
+    let fenceClose = -1;
+    for (let i = anchor.endLine - 1; i < lines.length; i++) {
+        if (/^```\s*$/.test(lines[i])) {
+            fenceClose = i;
+            break;
+        }
+    }
+    if (fenceClose === -1) {
+        return invalid(`could not locate the fence enclosing anchor ${afterId}`);
+    }
+    const bodyLines = body.split("\n");
+    const block = ["", "```yaml", "---", ...bodyLines, "---", "```"];
+    const newLines = [
+        ...lines.slice(0, fenceClose + 1),
+        ...block,
+        ...lines.slice(fenceClose + 1),
+    ];
+    await ports.writer.writeSpecFile(cwd, anchor.entry.path, newLines.join("\n"));
+    const startLine = fenceClose +
+        1 +
+        3 +
+        1; /* ``` (1-based) + blank + ```yaml + --- → first body line */
+    return {
+        ok: true,
+        action: "add",
+        id: facts.id,
+        file: anchor.entry.path,
+        startLine,
+        endLine: startLine + bodyLines.length,
+    };
+}
+function locate(entries, id) {
+    const hits = [];
+    for (const entry of entries) {
+        for (const m of findMatches(entry.content.split(/\r?\n/), id)) {
+            hits.push({ entry, startLine: m.startLine, endLine: m.endLine });
+        }
+    }
+    return hits;
+}
+function invalid(message) {
+    return { ok: false, exitCode: 2, reason: "invalid-body", message };
+}
+function notFound(message) {
+    return { ok: false, exitCode: 1, reason: "anchor-not-found", message };
+}
+function ambiguous(message) {
+    return { ok: false, exitCode: 1, reason: "record-ambiguous", message };
+}
+function duplicate(message) {
+    return { ok: false, exitCode: 1, reason: "duplicate-id", message };
+}
+function governed(message) {
+    return { ok: false, exitCode: 1, reason: "record-protected", message };
+}

package/dist/features/record/application/GetRecord.d.ts

@@ -0,0 +1,8 @@
+import type { RecordSlice } from "../domain/RecordSlice.js";
+import type { RecordConfigPort } from "../ports/outbound/RecordConfigPort.js";
+import type { RecordFileReader } from "../ports/outbound/RecordFileReader.js";
+export type { RecordSlice };
+export declare function getRecord(cwd: string, id: string, ports: {
+    config: RecordConfigPort;
+    files: RecordFileReader;
+}): Promise<RecordSlice[]>;

package/dist/features/record/application/GetRecord.js

@@ -0,0 +1,22 @@
+import { findMatches } from "../../../shared/domain/SpecApprovalRewrite.js";
+export async function getRecord(cwd, id, ports) {
+    const config = await ports.config.config(cwd);
+    const entries = await ports.files.resolveSpecFiles(cwd, config.lint.specFiles);
+    const out = [];
+    for (const entry of entries) {
+        const lines = entry.content.split(/\r?\n/);
+        for (const match of findMatches(lines, id)) {
+            const raw = lines
+                .slice(match.startLine - 1, match.endLine - 1)
+                .join("\n");
+            out.push({
+                id: match.id,
+                file: entry.path,
+                startLine: match.startLine,
+                endLine: match.endLine,
+                raw,
+            });
+        }
+    }
+    return out;
+}

package/dist/features/record/application/ListRecords.d.ts

@@ -0,0 +1,9 @@
+import { type RecordSummary } from "../domain/RecordSummary.js";
+import type { RecordConfigPort } from "../ports/outbound/RecordConfigPort.js";
+import type { RecordFileReader } from "../ports/outbound/RecordFileReader.js";
+export type { RecordSummary };
+export interface RecordPorts {
+    config: RecordConfigPort;
+    files: RecordFileReader;
+}
+export declare function listRecords(cwd: string, ports: RecordPorts, partition?: string): Promise<RecordSummary[]>;

package/dist/features/record/application/ListRecords.js

@@ -0,0 +1,24 @@
+import { lintRecordsFromMarkdown } from "../../../shared/domain/SpecRecord.js";
+import { partitionOf } from "../domain/RecordPartition.js";
+import { titleOf } from "../domain/RecordSummary.js";
+export async function listRecords(cwd, ports, partition) {
+    const config = await ports.config.config(cwd);
+    const entries = await ports.files.resolveSpecFiles(cwd, config.lint.specFiles);
+    const out = [];
+    for (const entry of entries) {
+        for (const rec of lintRecordsFromMarkdown(entry.path, entry.content)) {
+            if (partition !== undefined && partitionOf(rec.id) !== partition) {
+                continue;
+            }
+            out.push({
+                id: rec.id,
+                type: rec.template,
+                status: rec.lifecycleStatus,
+                title: titleOf(rec.parsed),
+                file: rec.file,
+                line: rec.line,
+            });
+        }
+    }
+    return out;
+}

package/dist/features/record/application/SetRecord.d.ts

@@ -0,0 +1,11 @@
+import { type RecordWriteResult } from "../domain/RecordWrite.js";
+import type { RecordConfigPort } from "../ports/outbound/RecordConfigPort.js";
+import type { RecordFileReader } from "../ports/outbound/RecordFileReader.js";
+import type { RecordFileWriter } from "../ports/outbound/RecordFileWriter.js";
+export interface RecordWritePorts {
+    config: RecordConfigPort;
+    files: RecordFileReader;
+    writer: RecordFileWriter;
+}
+export type { RecordWriteResult };
+export declare function setRecord(cwd: string, id: string, rawBody: string, ports: RecordWritePorts): Promise<RecordWriteResult>;

package/dist/features/record/application/SetRecord.js

@@ -0,0 +1,68 @@
+import { findMatches } from "../../../shared/domain/SpecApprovalRewrite.js";
+import { lintRecordsFromMarkdown } from "../../../shared/domain/SpecRecord.js";
+import { inspectBody, normalizeBody } from "../domain/RecordBody.js";
+import { isProtectedStatus, } from "../domain/RecordWrite.js";
+export async function setRecord(cwd, id, rawBody, ports) {
+    const body = normalizeBody(rawBody);
+    const facts = inspectBody(body);
+    if (facts.id === null) {
+        return invalid("body has no id or does not parse as YAML");
+    }
+    if (facts.id !== id) {
+        return invalid(`body id (${facts.id}) does not match target id (${id})`);
+    }
+    if (isProtectedStatus(facts.status)) {
+        return governed(`refusing to set lifecycle.status ${facts.status}; promote via sdd approve + sdd finalize`);
+    }
+    const config = await ports.config.config(cwd);
+    const entries = await ports.files.resolveSpecFiles(cwd, config.lint.specFiles);
+    const hits = locate(entries, id);
+    if (hits.length === 0) {
+        return notFound(`record not found: ${id}`);
+    }
+    if (hits.length > 1) {
+        return ambiguous(`record id is ambiguous: ${id} matches ${hits.length} records`);
+    }
+    const hit = hits[0];
+    const current = lintRecordsFromMarkdown(hit.entry.path, hit.entry.content).find((r) => r.id === id);
+    if (current !== undefined && isProtectedStatus(current.lifecycleStatus)) {
+        return governed(`refusing to edit ${current.lifecycleStatus} record ${id}; use sdd approve + sdd finalize`);
+    }
+    const lines = hit.entry.content.split(/\r?\n/);
+    const bodyLines = body.split("\n");
+    const newLines = [
+        ...lines.slice(0, hit.startLine - 1),
+        ...bodyLines,
+        ...lines.slice(hit.endLine - 1),
+    ];
+    await ports.writer.writeSpecFile(cwd, hit.entry.path, newLines.join("\n"));
+    return {
+        ok: true,
+        action: "set",
+        id,
+        file: hit.entry.path,
+        startLine: hit.startLine,
+        endLine: hit.startLine + bodyLines.length,
+    };
+}
+function locate(entries, id) {
+    const hits = [];
+    for (const entry of entries) {
+        for (const m of findMatches(entry.content.split(/\r?\n/), id)) {
+            hits.push({ entry, startLine: m.startLine, endLine: m.endLine });
+        }
+    }
+    return hits;
+}
+function invalid(message) {
+    return { ok: false, exitCode: 2, reason: "invalid-body", message };
+}
+function notFound(message) {
+    return { ok: false, exitCode: 1, reason: "record-not-found", message };
+}
+function ambiguous(message) {
+    return { ok: false, exitCode: 1, reason: "record-ambiguous", message };
+}
+function governed(message) {
+    return { ok: false, exitCode: 1, reason: "record-protected", message };
+}

package/dist/features/record/domain/RecordBody.d.ts

@@ -0,0 +1,12 @@
+/** Normalise a supplied record body to the bare YAML body (the form
+ *  `sdd record get` emits): strip an enclosing ```yaml fence and any
+ *  surrounding `---` document markers, then trim blank edges. */
+export declare function normalizeBody(raw: string): string;
+export interface BodyFacts {
+    id: string | null;
+    status: string | null;
+}
+/** Best-effort parse of a record body to its id and lifecycle status.
+ *  Unparseable input yields `{ id: null, status: null }` so callers treat
+ *  it as an invalid body. */
+export declare function inspectBody(body: string): BodyFacts;

package/dist/features/record/domain/RecordBody.js

@@ -0,0 +1,66 @@
+import { parseDocument } from "yaml";
+/** Normalise a supplied record body to the bare YAML body (the form
+ *  `sdd record get` emits): strip an enclosing ```yaml fence and any
+ *  surrounding `---` document markers, then trim blank edges. */
+export function normalizeBody(raw) {
+    let lines = raw.replace(/\r\n/g, "\n").split("\n");
+    lines = trimBlankEdges(lines);
+    if (lines.length > 0 && /^```yaml\s*$/.test(lines[0])) {
+        const close = lines.findIndex((l, i) => i > 0 && /^```\s*$/.test(l));
+        if (close !== -1) {
+            lines = trimBlankEdges(lines.slice(1, close));
+        }
+    }
+    if (lines.length > 0 && lines[0] === "---") {
+        lines = lines.slice(1);
+    }
+    if (lines.length > 0 && lines[lines.length - 1] === "---") {
+        lines = lines.slice(0, -1);
+    }
+    return trimBlankEdges(lines).join("\n");
+}
+/** Best-effort parse of a record body to its id and lifecycle status.
+ *  Unparseable input yields `{ id: null, status: null }` so callers treat
+ *  it as an invalid body. */
+export function inspectBody(body) {
+    const doc = parseDocument(body, { prettyErrors: false });
+    if (doc.errors.length > 0) {
+        return { id: null, status: null };
+    }
+    const value = doc.toJS();
+    if (!isRecord(value)) {
+        return { id: null, status: null };
+    }
+    const obj = value;
+    const id = typeof obj.id === "string" ? obj.id : null;
+    const status = lifecycleStatus(obj);
+    return { id, status };
+}
+function lifecycleStatus(obj) {
+    const flat = obj["lifecycle.status"];
+    if (typeof flat === "string") {
+        return flat;
+    }
+    const lifecycle = obj.lifecycle;
+    if (isRecord(lifecycle)) {
+        const status = lifecycle.status;
+        if (typeof status === "string") {
+            return status;
+        }
+    }
+    return null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function trimBlankEdges(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && lines[start].trim().length === 0) {
+        start++;
+    }
+    while (end > start && lines[end - 1].trim().length === 0) {
+        end--;
+    }
+    return lines.slice(start, end);
+}

package/dist/features/record/domain/RecordPartition.d.ts

@@ -0,0 +1 @@
+export declare function partitionOf(id: string): string;

package/dist/features/record/domain/RecordPartition.js

@@ -0,0 +1,7 @@
+/* CST-007: partition component of a normative ID. The ID-tail has no `:`,
+ * so the rightmost colon splits `<partition>:<tail>`; a bare id is its own
+ * partition. See spec record. */
+export function partitionOf(id) {
+    const idx = id.lastIndexOf(":");
+    return idx === -1 ? id : id.slice(0, idx);
+}

package/dist/features/record/domain/RecordSlice.d.ts

@@ -0,0 +1,7 @@
+export interface RecordSlice {
+    id: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+    raw: string;
+}

package/dist/features/record/domain/RecordSlice.js

@@ -0,0 +1 @@
+export {};

package/dist/features/record/domain/RecordSummary.d.ts

@@ -0,0 +1,11 @@
+export interface RecordSummary {
+    id: string;
+    type: string | null;
+    status: string | null;
+    title: string | null;
+    file: string;
+    line: number;
+}
+/** Derive a one-line display title for a record. Fixed fallback chain:
+ *  the `title` field, else the `name` field (Surface records), else null. */
+export declare function titleOf(parsed: Record<string, unknown>): string | null;

package/dist/features/record/domain/RecordSummary.js

@@ -0,0 +1,13 @@
+/** Derive a one-line display title for a record. Fixed fallback chain:
+ *  the `title` field, else the `name` field (Surface records), else null. */
+export function titleOf(parsed) {
+    const title = parsed.title;
+    if (typeof title === "string") {
+        return title;
+    }
+    const name = parsed.name;
+    if (typeof name === "string") {
+        return name;
+    }
+    return null;
+}

package/dist/features/record/domain/RecordWrite.d.ts

@@ -0,0 +1,14 @@
+export type RecordWriteResult = {
+    ok: true;
+    action: "set" | "add";
+    id: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+} | {
+    ok: false;
+    exitCode: 1 | 2;
+    reason: string;
+    message: string;
+};
+export declare function isProtectedStatus(status: string | null): boolean;

package/dist/features/record/domain/RecordWrite.js

@@ -0,0 +1,8 @@
+const PROTECTED_STATUSES = new Set([
+    "approved",
+    "deprecated",
+    "removed",
+]);
+export function isProtectedStatus(status) {
+    return status !== null && PROTECTED_STATUSES.has(status);
+}

package/dist/features/record/ports/inbound/RecordCommand.d.ts

@@ -0,0 +1,19 @@
+import type { CommandResult, OutputFormat } from "../../../../shared/domain/CliOutput.js";
+export type RecordAction = {
+    kind: "list";
+    partition?: string;
+} | {
+    kind: "get";
+    id: string;
+} | {
+    kind: "set";
+    id: string;
+    body: string;
+} | {
+    kind: "add";
+    afterId: string;
+    body: string;
+};
+export interface RecordCommand {
+    execute(cwd: string, action: RecordAction, format: Exclude<OutputFormat, "yaml">): Promise<CommandResult>;
+}

package/dist/features/record/ports/inbound/RecordCommand.js

@@ -0,0 +1 @@
+export {};

package/dist/features/record/ports/outbound/RecordConfigPort.d.ts

@@ -0,0 +1,4 @@
+import type { SddConfig } from "../../../../shared/domain/Config.js";
+export interface RecordConfigPort {
+    config(repoRoot: string): Promise<SddConfig>;
+}

package/dist/features/record/ports/outbound/RecordConfigPort.js

@@ -0,0 +1 @@
+export {};

package/dist/features/record/ports/outbound/RecordFileReader.d.ts

@@ -0,0 +1,10 @@
+export interface SpecFileEntry {
+    /** Path relative to repoRoot. */
+    path: string;
+    /** UTF-8 markdown content. */
+    content: string;
+}
+export interface RecordFileReader {
+    /** Resolve glob patterns to a deduplicated list of {path, content} entries. */
+    resolveSpecFiles(repoRoot: string, patterns: readonly string[]): Promise<SpecFileEntry[]>;
+}

package/dist/features/record/ports/outbound/RecordFileReader.js

@@ -0,0 +1 @@
+export {};

package/dist/features/record/ports/outbound/RecordFileWriter.d.ts

@@ -0,0 +1,6 @@
+export interface RecordFileWriter {
+    /** Atomically write `content` to the spec file at `relativePath` (relative
+     *  to repoRoot). Must be a temp-write + rename so a crash never leaves a
+     *  partial file. */
+    writeSpecFile(repoRoot: string, relativePath: string, content: string): Promise<void>;
+}

package/dist/features/record/ports/outbound/RecordFileWriter.js

@@ -0,0 +1 @@
+export {};

package/dist/features/refresh/adapters/inbound/CliRefreshHandler.d.ts

@@ -0,0 +1,8 @@
+import { type CommandResult, type OutputFormat } from "../../../../shared/domain/CliOutput.js";
+import { type BuildRefreshStubsPorts } from "../../application/BuildRefreshStubs.js";
+import type { RefreshCommand } from "../../ports/inbound/RefreshCommand.js";
+export declare class CliRefreshHandler implements RefreshCommand {
+    private readonly ports;
+    constructor(ports: BuildRefreshStubsPorts);
+    execute(cwd: string, format: OutputFormat): Promise<CommandResult>;
+}

package/dist/features/refresh/adapters/inbound/CliRefreshHandler.js

@@ -0,0 +1,24 @@
+import { failed, ok, } from "../../../../shared/domain/CliOutput.js";
+import { CliFailure } from "../../../../shared/domain/Errors.js";
+import { buildRefreshStubs, } from "../../application/BuildRefreshStubs.js";
+export class CliRefreshHandler {
+    ports;
+    constructor(ports) {
+        this.ports = ports;
+    }
+    async execute(cwd, format) {
+        try {
+            const outcome = await buildRefreshStubs(cwd, format, this.ports);
+            if (outcome.kind === "json") {
+                return ok(JSON.stringify(outcome.body));
+            }
+            return ok(outcome.text);
+        }
+        catch (error) {
+            if (error instanceof CliFailure) {
+                return failed(error, format);
+            }
+            throw error;
+        }
+    }
+}

package/dist/features/refresh/adapters/outbound/ChildProcessRefreshGit.d.ts

@@ -0,0 +1,8 @@
+import type { RefreshGitPort } from "../../ports/outbound/RefreshGitPort.js";
+export declare class ChildProcessRefreshGit implements RefreshGitPort {
+    repoRoot(cwd: string): Promise<string>;
+    headSha(repoRoot: string): Promise<string>;
+    treePaths(repoRoot: string, scope: readonly string[]): Promise<string[]>;
+    dirtyPaths(repoRoot: string, scope: readonly string[]): Promise<string[]>;
+    changedPaths(repoRoot: string, baselineCommitSha: string, scope: readonly string[]): Promise<string[]>;
+}

package/dist/features/refresh/adapters/outbound/ChildProcessRefreshGit.js

@@ -0,0 +1,118 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { configFailure, environmentFailure, } from "../../../../shared/domain/Errors.js";
+export class ChildProcessRefreshGit {
+    async repoRoot(cwd) {
+        const result = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+        if (result.code !== 0 || result.stdout.toString("utf8").trim() !== "true") {
+            throw environmentFailure("not-a-git-repo", "cwd is not inside a git working tree", cwd);
+        }
+        return findRepoRoot(cwd);
+    }
+    async headSha(repoRoot) {
+        const result = await runGit(repoRoot, ["rev-parse", "HEAD"]);
+        if (result.code === 0) {
+            return result.stdout.toString("utf8").trim();
+        }
+        throw environmentFailure("head-unborn", "HEAD does not resolve to a commit", result.stderr.toString("utf8").trim());
+    }
+    async treePaths(repoRoot, scope) {
+        const result = await runGit(repoRoot, [
+            "ls-tree",
+            "-r",
+            "--name-only",
+            "HEAD",
+            "--",
+            ...scope,
+        ]);
+        if (result.code !== 0) {
+            throw environmentFailure("head-unborn", "git ls-tree failed", result.stderr.toString("utf8").trim());
+        }
+        return nonEmptyLines(result.stdout.toString("utf8"));
+    }
+    async dirtyPaths(repoRoot, scope) {
+        const diffResult = await runGit(repoRoot, [
+            "diff",
+            "--quiet",
+            "HEAD",
+            "--",
+            ...scope,
+        ]);
+        if (diffResult.code !== 0 && diffResult.code !== 1) {
+            throw environmentFailure("head-unborn", "git diff --quiet failed", diffResult.stderr.toString("utf8").trim());
+        }
+        const result = await runGit(repoRoot, [
+            "status",
+            "--porcelain",
+            "--",
+            ...scope,
+        ]);
+        if (result.code !== 0) {
+            throw environmentFailure("not-a-git-repo", "git status failed", result.stderr.toString("utf8").trim());
+        }
+        return nonEmptyLines(result.stdout.toString("utf8"))
+            .map((line) => porcelainPath(line))
+            .sort();
+    }
+    async changedPaths(repoRoot, baselineCommitSha, scope) {
+        const result = await runGit(repoRoot, [
+            "diff",
+            "--name-only",
+            `${baselineCommitSha}..HEAD`,
+            "--",
+            ...scope,
+        ]);
+        if (result.code !== 0) {
+            throw configFailure("config-invalid", `baseline_commit_sha does not resolve: ${baselineCommitSha}`, result.stderr.toString("utf8").trim());
+        }
+        return nonEmptyLines(result.stdout.toString("utf8")).sort();
+    }
+}
+function runGit(cwd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("git", [...args], {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            if (error.code === "ENOENT") {
+                reject(environmentFailure("git-not-on-path", "git binary is not on PATH"));
+                return;
+            }
+            reject(error);
+        });
+        child.on("close", (code) => {
+            resolve({
+                code: code ?? 1,
+                stdout: Buffer.concat(stdout),
+                stderr: Buffer.concat(stderr),
+            });
+        });
+    });
+}
+function nonEmptyLines(value) {
+    return value.split(/\r?\n/).filter((line) => line.length > 0);
+}
+function porcelainPath(line) {
+    const raw = line.slice(3);
+    const parts = raw.split(" -> ");
+    return parts[parts.length - 1];
+}
+function findRepoRoot(cwd) {
+    let current = resolve(cwd);
+    while (true) {
+        if (existsSync(join(current, ".git"))) {
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            throw environmentFailure("not-a-git-repo", "cwd is not inside a git working tree", cwd);
+        }
+        current = parent;
+    }
+}

package/dist/features/refresh/adapters/outbound/NodeRefreshFileReader.d.ts

@@ -0,0 +1,7 @@
+import { type SddConfig } from "../../../../shared/domain/Config.js";
+import type { RefreshConfigPort } from "../../ports/outbound/RefreshConfigPort.js";
+import type { RefreshSpec, RefreshSpecPort } from "../../ports/outbound/RefreshSpecPort.js";
+export declare class NodeRefreshFileReader implements RefreshConfigPort, RefreshSpecPort {
+    config(repoRoot: string): Promise<SddConfig>;
+    spec(repoRoot: string, config: SddConfig): Promise<RefreshSpec>;
+}