@nelsonlongxiang/dsh-open-a2a-net 0.6.30 → 0.6.32

package/lib/types/index.d.ts

@@ -19,6 +19,8 @@ export declare function resolveCallerLabel(input: {
     sessionLabel?: string;
 }): string | undefined;
 import { type ReceiptResolvedInfo } from './task-ledger.ts';
+import { type AffectedEntry } from './auth-observer.ts';
+import { type SettlementMode } from './task-auth.ts';
 import type { Context } from '@deepseek-ai/cordis';
 import s from '@deepseek-ai/schemastery';
 declare module '@deepseek-ai/dsh-llm' {
@@ -42,6 +44,8 @@ export type { ReceiptResolvedInfo } from './task-ledger.ts';
 declare module '@deepseek-ai/cordis' {
     interface Events {
         'a2a/receipt-resolved'(payload: ReceiptResolvedInfo): void;
+        /** #114 S6: an allowlist change left unsettled tasks on another footing (observe mode — nothing is cancelled). */
+        'a2a/authorization-affected'(payload: AffectedEntry): void;
     }
 }
 export declare const name = "a2a";
@@ -70,6 +74,8 @@ export interface Config {
     readonly team: string;
     /** S4 fix 3: audit (default) or refuse host-side (agent-less) routing calls. */
     readonly gateAgentLessCalls: 'audit' | 'refuse';
+    /** #114 S4: settlement authorization — off, observe (record would-refuse, settle as before), enforce. */
+    readonly settlementAuth: SettlementMode;
     /**
      * Publish this node's `/.well-known/agent-card.json` on the shared web
      * server (peer discovery). Requires the web server in the composition;
@@ -77,6 +83,14 @@ export interface Config {
      * joined session teams so peers find it without a central directory.
      */
     readonly announce: boolean;
+    /**
+     * gh#193: send nothing to any peer. Every outbound peer request — card
+     * reads, directory sweeps, routes, log reads, canvas pings and canvas-op
+     * relays — goes through one fetch that refuses while this is on, so a
+     * test host stays dark even with learned peers in `a2a/peers.json`
+     * (which is left untouched). Inbound faces keep answering. Default false.
+     */
+    readonly isolated: boolean;
     /** Human-facing name published on the agent card. */
     readonly agentName: string;
     /**
@@ -103,6 +117,19 @@ export interface Config {
      * self-asserted already-linked name must not pass on shape alone).
      */
     readonly originClaimWindow: boolean;
+    /**
+     * OriginClaim unbound window (docs/protocol/delivery-origin-auth.md §2.1):
+     * while true (default), this host also signs the legacy unbound form and
+     * accepts a peer's unbound-only envelope (counted as unboundInbound);
+     * closed, it signs and accepts the audience-bound form only.
+     */
+    readonly originClaimUnboundWindow: boolean;
+    /**
+     * Extra origins this host answers to as an OriginClaim audience, beyond
+     * its card URL and the address a request arrives on (port-mapped or
+     * proxied hosts name the URL peers dial).
+     */
+    readonly originClaimAudiences: string[];
     /**
      * #19 D2: card-face sessionTeams excerpt exposure — 'full' | 'masked'
      * | 'off' (owner-level; default full). See the schema comment.

package/lib/types/joined-store.d.ts

@@ -28,6 +28,7 @@ export declare class JoinedSessions {
     private readonly path;
     /** Session ids, most recently joined first. */
     private ids;
+    private readonly listeners;
     /**
      * @param path - persistence file (`<dsh-home>/a2a/joined.json`); empty = no persistence.
      */
@@ -54,6 +55,14 @@ export declare class JoinedSessions {
      * @param id - the session id whose intent is removed.
      */
     remove(id: string): void;
+    /**
+     * #114 S6: observe changes — the listener runs after every write that
+     * changed the store (never on restore or reload). A throwing listener
+     * cannot break the write.
+     * @returns the unsubscribe function.
+     */
+    onChange(listener: () => void): () => void;
+    private notify;
     /**
      * F7 (wake-intent self-heal): re-read the persisted snapshot into memory.
      * A boot-time transient (e.g. the workspace registry briefly reporting a

package/lib/types/ledger-conservation.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The ledger's conservation machinery (gh#154): four lifetime counters plus
+ * the durable damage marker, moved verbatim out of TaskLedger so each module
+ * stays under the R-mod cap. Counting semantics live here; the ledger's
+ * track / archiveSettled / restore / persist seams delegate.
+ *
+ * Identity: trackedTotal = |owed| + Σ archivedByEnd + restoreTrimmed.
+ * Duplicates are checked by the ledger (it owns the rows); counters only
+ * answer the count half. A persisted damage marker never clears on its own —
+ * only an explicit reseed policy may clear it (none exists by design).
+ * @module src/ledger-conservation
+ */
+import type { ArchiveEnd } from './task-ledger.ts';
+/** The persisted conservation block (rides the ledger snapshot; absent = pre-#154 legacy). */
+export interface ConservationSnapshot {
+    readonly trackedTotal: number;
+    readonly archivedByEnd: Record<ArchiveEnd, number>;
+    readonly archiveTrimmed: number;
+    readonly restoreTrimmed: number;
+    /** review r2: a damage marker PERSISTS — restarts keep refusing conserved until an explicit reseed clears it. */
+    readonly damaged?: string;
+}
+/** One full conservation verdict (the /state projection). */
+export interface ConservationVerdict {
+    conserved: boolean;
+    delta: number;
+    trackedTotal: number;
+    owed: number;
+    archivedByEnd: Record<ArchiveEnd, number>;
+    archivedTotal: number;
+    archiveTrimmed: number;
+    restoreTrimmed: number;
+    duplicateTaskIds: string[];
+    damaged?: string;
+}
+/** The archive-row shape the bootstrap classifier reads (endedBy optional pre-gh#31; generic so the ledger passes its own row type). */
+export type ArchiveClassifiable = {
+    readonly endedBy?: ArchiveEnd;
+};
+/** The parsed outcome of restoring counters from one snapshot. */
+export type ConservationRestore = {
+    readonly kind: 'legacy';
+} | {
+    readonly kind: 'valid';
+    readonly snapshot: ConservationSnapshot;
+} | {
+    readonly kind: 'damaged';
+    readonly reason: string;
+};
+/**
+ * Restore-classify one snapshot's conservation block:
+ * - absent block → legacy bootstrap from what the rows prove;
+ * - present, fully valid (every field a non-negative integer, archiveTrimmed
+ *   bounded by the lifetime archived total, optional damaged marker a
+ *   non-empty string) → valid, counters load as persisted;
+ * - anything else (partial, negative, fractional, null body, unbounded trim)
+ *   → damaged: counters stay zero and the verdict refuses conserved.
+ */
+export declare function classifyConservationBlock(raw: unknown): ConservationRestore;
+/** The counters themselves — one mutable holder the ledger owns. */
+export declare class ConservationCounters {
+    trackedTotal: number;
+    readonly archivedByEnd: Record<ArchiveEnd, number>;
+    archiveTrimmed: number;
+    restoreTrimmed: number;
+    damaged: string | undefined;
+    /** Legacy bootstrap: the kept rows plus this load's cuts are all the snapshot proves. */
+    legacyBootstrap<T extends {
+        readonly endedBy?: ArchiveEnd;
+    }>(owedCount: number, archive: readonly T[], restoreTrimmed: number, classify: (row: T) => ArchiveEnd): void;
+    /** Valid-block load: counters EXACTLY as persisted (review P2: an undercount stays red — never repaired upward); restoreTrimmed ADDS this load's cuts to the persisted lifetime (review P2: neither overwrite nor max). */
+    loadFrom(snapshot: ConservationSnapshot, owedCount: number, archiveCount: number): void;
+    /** The persisted shape (damaged rides along once stamped). */
+    toSnapshot(): ConservationSnapshot;
+    /** The verdict's count half (the ledger supplies rows, owed count, duplicates). */
+    verdict(owedCount: number, archiveCount: number, duplicateTaskIds: string[]): ConservationVerdict;
+}

package/lib/types/legacy/teams-bridge-inbound.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The native-teams inbound bridge (gh#77 G-segment, inbound half), moved
+ * verbatim out of apply() in src/index.ts: the structural registry probe, the
+ * memoized claim check, prepare (claim + seam + parent), and the bounded
+ * round. Opt-in behind config.nativeTeamsInbound; when the sibling
+ * @nelsonlongxiang/dsh-native-teams plugin is not composed every probe
+ * declines and the standard resolution chain keeps its verdict.
+ *
+ * The OUTBOUND bridgeFace stays with the dispatch trunk in index.ts until the
+ * G-out slice - it submits through the trunk's candidate walk (bidirectional
+ * coupling), which is why #77 prescribes taking G in pieces.
+ * @module src/legacy/teams-bridge-inbound
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Config } from '../index.ts';
+/** Structural descriptor of one team name across planes (the registry's answer). */
+export interface BridgeTeamsDescriptor {
+    readonly plane: 'local' | 'a2a';
+    readonly ambiguous?: boolean;
+    readonly localLabel?: string;
+}
+/** The sibling registry's widened structural face (presence-guarded probe). */
+export interface BridgeTeamsRegistry {
+    listTeams(): Array<{
+        name: string;
+        description: string;
+    }>;
+    describeTarget(handle: string): Promise<BridgeTeamsDescriptor>;
+    startRound(args: {
+        team?: string;
+        message: string;
+    }, parent: {
+        id: string;
+        session: {
+            events?: readonly unknown[];
+        };
+    }, signal: AbortSignal): Promise<string>;
+}
+/** A prepared dispatch: claim verified, seam live, parent initiator found. */
+export type NativeTeamsPrepared = {
+    readonly ok: true;
+    readonly teams: BridgeTeamsRegistry;
+    readonly parent: {
+        id: string;
+        session: {
+            events?: readonly unknown[];
+        };
+    };
+} | {
+    readonly ok: false;
+    readonly reason: 'not-claimed';
+} | {
+    readonly ok: false;
+    readonly reason: 'error';
+    readonly error: string;
+};
+/** The bounded round's outcome (settled / unsettled-deadline / failed / aborted). */
+export type NativeTeamsRoundOutcome = {
+    readonly ok: true;
+    readonly reply: string;
+    readonly settled: boolean;
+} | {
+    readonly ok: false;
+    readonly error: string;
+    readonly phase?: 'pre-dispatch';
+    readonly aborted?: boolean;
+};
+/** Everything the inbound bridge captures from apply(). */
+export interface TeamsBridgeInboundDeps {
+    readonly ctx: Context;
+    readonly config: Config;
+    readonly liveAgent: () => Agent | undefined;
+    readonly fromClause: (from: string) => string;
+    readonly sanitizeFromClause: (from: string) => string;
+    readonly proofHeader?: (team: string, taskId: string, from: string, proofClause: string) => string;
+    /** N4 session taint: the round about to carry remote text runs under this parent (its members derive from it). */
+    readonly taint?: (agent: Agent) => void;
+}
+/** The four inbound-bridge operations, verbatim from apply(). */
+export interface TeamsBridgeInbound {
+    teamsRegistry(): BridgeTeamsRegistry | undefined;
+    nativeTeamsClaims(team: string): Promise<boolean>;
+    nativeTeamsPrepare(team: string): Promise<NativeTeamsPrepared>;
+    nativeTeamsRound(prepared: Extract<NativeTeamsPrepared, {
+        ok: true;
+    }>, team: string, caller: string, message: string, taskId: string | undefined, proofClause: string, external?: AbortSignal, proofHeader?: (team: string, taskId: string, from: string, proofClause: string) => string): Promise<NativeTeamsRoundOutcome>;
+}
+/**
+ * Build the inbound bridge. The bodies are byte-identical to their apply()
+ * originals (same two-space indent); only the four capture points arrive as
+ * deps.
+ */
+export declare function createTeamsBridgeInbound(deps: TeamsBridgeInboundDeps): TeamsBridgeInbound;

package/lib/types/node-bind.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Session ↔ node binding (docs/design/node-identity.md, slices N2+N3).
+ *
+ * - A binding ties one JOINED session to one node (§3): a session carries
+ *   at most one node, a node may have several live sessions. The table is
+ *   `node-bindings.json` under the a2a home; it survives restarts and
+ *   cooling unloads (`agent/disposed` is not the end of a binding).
+ * - A binding ends when the session leaves the network (leave, or its join
+ *   intent falls off JOIN_CAP), or when its node is archived: the row is
+ *   deleted and the sections come off. An ARCHIVED session never mounts and
+ *   cannot bind; its row is kept, like its join intent (the 3081 lesson: a
+ *   transient archived reading must not destroy durable intent).
+ * - Mounts belong to the session scope, not to this plugin: the plugin
+ *   disposes every mount it made when it unloads (`disposeAll`), so a
+ *   reloaded plugin never meets registrations it cannot see.
+ * - Binding mounts at once (§3 "绑定即生效"): two prompt sections are
+ *   registered on that session's own `agent.ctx` — the mutable layer at
+ *   10150, the core layer after it at 10180 with an explicit precedence
+ *   line, both before the deployment suffix at 10200 (§5).
+ * - Frozen snapshot (§5): the texts are read once, when the session mounts.
+ *   A layer written later takes effect from the session's next mount
+ *   (resume / clear / compact re-publish it), never mid-session: the binding
+ *   row records the versions each mount froze, and a plugin reload re-mounts
+ *   live sessions at them (#174).
+ * - No interpolation (§5, B3): the installed system-prompt has no
+ *   `interpolate:false`; it interpolates `{{name}}` groups and fails on an
+ *   unknown one. Each section's text is therefore only `{{a2a_node_*}}`,
+ *   and the frozen text rides a scoped prompt VARIABLE — substituted values
+ *   are never scanned again, so a `{{x}}` written into a layer stays literal
+ *   and assembly cannot fail on it.
+ * - Never a veto (§3): mounting runs inside `agent/created`, where a throw
+ *   would block the session from publishing. Every mount path catches and
+ *   logs; a corrupt roster, a missing node or a tampered version file
+ *   leaves the session without node sections, never without a session.
+ * - The task context `a2a:node:tasks` (N6) is LIVE, not frozen: it is a
+ *   runtime context that the system prompt materialises per assembly, so a
+ *   pointer that changes state shows at the next step (§5 "即时"). Its text
+ *   rides a scoped variable too. A pointer that finished calls `remind`:
+ *   each live session carrying that node gets a follow-up turn (§6).
+ * - `node_update_self` (N4) is registered with the sections on the bound
+ *   session's own scope, and leaves with them. A write it makes is echoed in
+ *   a live `a2a:node:self` context for the rest of that session (the frozen
+ *   sections do not change, §5).
+ * @module @nelsonlongxiang/dsh-open-a2a-net/node-bind
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type UserMessage } from '@deepseek-ai/dsh-llm';
+import { type NodeRecord, type NodeResult, type NodeStore, type PromptVersion } from './node-store.ts';
+import { type SelfUpdateDeps } from './node-self.ts';
+/** §5: section names, orders and the scoped variables that carry their frozen text. */
+export declare const NODE_PROMPT: {
+    readonly mutable: {
+        readonly section: "a2a:node:mutable";
+        readonly order: 10150;
+        readonly variable: "a2a_node_mutable";
+    };
+    readonly core: {
+        readonly section: "a2a:node:core";
+        readonly order: 10180;
+        readonly variable: "a2a_node_core";
+    };
+    readonly tasks: {
+        readonly context: "a2a:node:tasks";
+        readonly order: 9150;
+        readonly variable: "a2a_node_tasks";
+    };
+    readonly self: {
+        readonly context: "a2a:node:self";
+        readonly order: 9160;
+        readonly variable: "a2a_node_self";
+    };
+};
+export interface NodeBinding {
+    readonly session: string;
+    readonly node: string;
+    readonly by: string;
+    readonly at: string;
+    /**
+     * What the session's last mount froze, per layer: version (0 = the layer had none, so it mounts
+     * empty) and that version's sha. Absent = never recorded (an older row): the current version.
+     * A plugin reload re-mounts at these (#174).
+     */
+    readonly core_version?: number;
+    readonly core_sha256?: string;
+    readonly mutable_version?: number;
+    readonly mutable_sha256?: string;
+}
+/** One layer's frozen pin as recorded on a row, or undefined when the row never recorded it. */
+export type LayerPin = {
+    readonly version: number;
+    readonly sha256: string;
+} | undefined;
+/**
+ * A code fence left open would swallow everything rendered after it (even the core layer), so one
+ * still open at the end is closed. Tracked by the CommonMark rules: an opener is ``` or ~~~ (three
+ * or more) indented at most three spaces, and a backtick opener's info string has no backtick (else
+ * it is inline code); inside, only a run of the SAME character, at least as long, followed by nothing
+ * but blanks closes it. Lines split on CRLF, CR or LF alike; the closer carries the opener's indent, so
+ * a fence opened inside a list item is closed inside it rather than opening a new one at column 0.
+ */
+export declare function closeFences(text: string): string;
+export declare function fenceSafe(text: string): string;
+/** The mutable layer, fenced and marked lower than the core layer below it. '' when every section is empty. */
+export declare function renderMutable(v: PromptVersion | undefined): string;
+/** The core layer: identity from the record, the human-written text, and the precedence line. */
+export declare function renderCore(node: NodeRecord, v: PromptVersion | undefined): string;
+/**
+ * The binding table. A file that does not parse is left in place and the
+ * table comes back READ-ONLY and empty (sessions open, nothing mounts);
+ * a copy is kept beside it, as the node roster does.
+ */
+export declare class NodeBindings {
+    private readonly root;
+    private readonly now;
+    private rows;
+    private readOnlyReason;
+    /** @param root - the `<home>/a2a` directory; '' keeps the table in memory (tests). */
+    constructor(root: string, now?: () => string);
+    private get file();
+    private restore;
+    private commit;
+    get readOnly(): string;
+    list(): readonly NodeBinding[];
+    get(session: string): NodeBinding | undefined;
+    set(session: string, node: string, by: string): NodeResult<NodeBinding>;
+    /** Record what a mount froze (best effort; unchanged values write nothing). */
+    setFrozen(session: string, core: {
+        version: number;
+        sha256: string;
+    }, mutable: {
+        version: number;
+        sha256: string;
+    }): NodeResult<true>;
+    delete(session: string): NodeResult<true>;
+    /** Delete every row matching `drop` in one write; the deleted rows on success. */
+    deleteWhere(drop: (b: NodeBinding) => boolean): NodeResult<NodeBinding[]>;
+}
+/** The part of a live session the binder touches: its id and its own registration scope. */
+export interface BindableAgent {
+    readonly id: unknown;
+    readonly ctx: Context;
+    /** Queue a follow-up turn (the §6 reminder); absent on test doubles that never get one. */
+    followup?(message: UserMessage): void;
+    /** Queue a message for the next turn without waking (an owed reminder handed out at mount). */
+    send?(message: UserMessage, target: 'next-turn' | 'next-step', wakeup: boolean): void;
+}
+export interface MountedNode {
+    readonly node: string;
+    readonly core_version: number;
+    readonly mutable_version: number;
+}
+export interface NodeBinderDeps {
+    readonly store: NodeStore;
+    readonly bindings: NodeBindings;
+    readonly logger: {
+        warn: (format: string, ...args: unknown[]) => void;
+    };
+    /** Whether a session is joined (§3: only a joined session binds). */
+    readonly joined: (session: string) => boolean;
+    /** Every joined session now (reconcile works on the difference from the last reading). */
+    readonly joinedList: () => readonly string[];
+    /** Whether a session is archived (it never mounts and cannot bind). */
+    readonly archived: (session: string) => boolean;
+    /** The live top-level session with this id, if any. */
+    readonly live: (session: string) => BindableAgent | undefined;
+    /** The node's task context text, read at each assembly ('' = none). */
+    readonly tasksText?: (node: string) => string;
+    /** Reminders owed to the node (finished while no session carried it); taken — and cleared — at mount. */
+    readonly pendingReminders?: (node: string) => string[];
+    /** N4: what `node_update_self` needs (absent = no tool). */
+    readonly selfUpdate?: Omit<SelfUpdateDeps, 'onWritten'>;
+}
+export interface NodeBinder {
+    /**
+     * Mount the session's bound node, if any. Never throws (it runs inside agent/created). A new session
+     * (agent/created) takes the current versions; `atFrozen` — the plugin-load pass over sessions that are
+     * already live — re-mounts at the versions the row recorded, so a plugin reload never changes a live
+     * session's head (§5; #174). A recorded version that no longer reads back falls back to the current one.
+     */
+    mount(agent: BindableAgent, opts?: {
+        atFrozen?: boolean;
+    }): void;
+    /** Take a live session's node sections off, keeping its binding row (an archived session). */
+    suspend(session: string): void;
+    /** Forget a session's mount without touching its binding (cooling unload; the scope disposes itself). */
+    forget(session: string): void;
+    /** What a live session currently carries (the frozen snapshot), if anything. */
+    mounted(session: string): MountedNode | undefined;
+    /**
+     * #174: whether the session's assembled system prompt still carries the two node sections. A
+     * `complete` preset replaces the whole prompt and drops them though they stay mounted. Assembles
+     * with the session's own scope, as the agent loop does; undefined when the session carries no node
+     * or the assembly fails.
+     */
+    assembled(session: string): Promise<{
+        core: boolean;
+        mutable: boolean;
+    } | undefined>;
+    bind(session: string, node: string, by: string): NodeResult<NodeBinding & {
+        mounted: boolean;
+    }>;
+    unbind(session: string): NodeResult<true>;
+    /**
+     * End the bindings of sessions that LEFT since the last reading (leave, JOIN_CAP eviction). Only
+     * the difference counts: a joined.json that failed to parse reads as empty, and treating every
+     * session as "left" on that reading would end every binding (the 3081 lesson). A failed write keeps
+     * the leavers for the next reading (retry). A session that (re)joined and carries a binding row
+     * mounts at once, if live. Never throws.
+     */
+    reconcile(): void;
+    /** End every binding to an archived node. */
+    nodeArchived(node: string): void;
+    /** Dispose every mount this binder made (plugin unload). */
+    disposeAll(): void;
+    /** Queue a follow-up turn on every live, mounted session carrying `node` (§6 reminder); how many got it. */
+    remind(node: string, text: string): number;
+}
+/** One §6 reminder as a user message; the sender label makes ui-chat render it as "来自 …" with the text. */
+export declare function reminderMessage(node: string, text: string): UserMessage;
+export declare function createNodeBinder(d: NodeBinderDeps): NodeBinder;

package/lib/types/node-github.d.ts

@@ -0,0 +1,35 @@
+/**
+ * GitHub check for node task pointers (docs/design/node-identity.md §6, §8-8; slice N6).
+ *
+ * - Credentials are the host's own: `GITHUB_TOKEN` in the environment, else
+ *   an existing `gh` login. The plugin stores none.
+ * - One call per pointer: the issues endpoint answers for issues AND pull
+ *   requests (`pull_request.merged_at` says whether a PR merged).
+ * - Anything that is not a clean answer — no credential, offline, rate
+ *   limited, a malformed body — is `undefined`: the state is UNKNOWN, never
+ *   guessed, and an unknown state never triggers a reminder.
+ * @module @nelsonlongxiang/dsh-open-a2a-net/node-github
+ */
+export type TaskState = 'open' | 'merged' | 'closed' | 'declined';
+/** `owner/repo#n` — the pointer form (GitHub's own owner and repo character sets; `.` and `..` are no repo). */
+export declare const TASK_REF: RegExp;
+/** One pointer's state on GitHub, and when it finished (merged_at / closed_at), if it did. */
+export interface TaskFact {
+    readonly state: TaskState;
+    readonly finishedAt?: string;
+}
+/** One pointer's fact on GitHub, or undefined when it cannot be known right now. */
+export type GithubProbe = (ref: string) => Promise<TaskFact | undefined>;
+/** Map one issues-API body to a fact; undefined for anything that does not look like one. */
+export declare function factOf(body: unknown): TaskFact | undefined;
+/** Just the state of {@link factOf}. */
+export declare function stateOf(body: unknown): TaskState | undefined;
+export interface GithubProbeDeps {
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly fetch?: typeof globalThis.fetch;
+    /** Runs `gh api <path>` and resolves its stdout; rejects when gh is missing, logged out or fails. */
+    readonly gh?: (path: string) => Promise<string>;
+    readonly timeoutMs?: number;
+}
+/** The production probe: token first, then `gh`, else unknown. Never throws. */
+export declare function githubProbe(d?: GithubProbeDeps): GithubProbe;