@skrr-ai/cli 0.1.129 → 0.1.131

package/dist/commands/tasks/self-schedule.d.ts

@@ -23,8 +23,64 @@ export default class TasksSelfSchedule extends BaseCommand {
         in: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         note: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'max-per-day': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        're-enable': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         show: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         clear: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }
+/** What the server records about a return that came due (`lastDecision` on the GET). */
+export interface ReturnDecision {
+    outcome?: string;
+    /** ran | skipped | failed | waiting. Absent from a server older than this field. */
+    verdict?: 'ran' | 'skipped' | 'failed' | 'waiting';
+    reason?: string | null;
+    /** The reason in plain words, when the server has some for it. */
+    reasonText?: string | null;
+    at?: string | null;
+}
+/** The part after "the return came due and": what became of it, with the reason. */
+export declare function decisionClause(decision: ReturnDecision): string;
+/**
+ * The line `--show` prints for a return whose time has passed. "returned at" is
+ * said only when a run really started; a skipped, failed or unrecorded return
+ * says what it was.
+ */
+export declare function describeSpentReturn({ taskRef, runAt, decision, triggerId, bin, }: {
+    taskRef: string;
+    runAt: string;
+    decision?: ReturnDecision | null;
+    triggerId?: string;
+    bin?: string;
+}): string;
+/**
+ * `--in` as an instant. A value that does not parse says WHICH value, because
+ * the generic "pass --at or --in" this used to fall through to told a person who
+ * had passed `--in 1.5h` to pass `--in`.
+ *
+ * Seconds are accepted: the server owns the 60 s floor and answers
+ * `RETURN_TOO_SOON` with the bound, which is a better explanation than the CLI
+ * refusing the unit.
+ */
+export declare function resolveRelativeRunAt(relative: string, now?: number): {
+    runAt: string;
+} | {
+    error: string;
+};
+/**
+ * `--at` as a UTC instant. Any offset is accepted and normalised, so the server
+ * always receives `...Z`. A value with no zone is refused by saying so: it is a
+ * valid ISO-8601 string, and "Invalid ISO datetime" for it read as if the CLI
+ * could not parse a thing the help had just told the person to type.
+ */
+export declare function resolveAbsoluteRunAt(absolute: string): {
+    runAt: string;
+} | {
+    error: string;
+};
+/** `--at`, or `--in`, or neither (undefined). Absolute wins when both are given. */
+export declare function resolveRunAt(at?: string, relative?: string, now?: number): {
+    runAt: string;
+} | {
+    error: string;
+} | undefined;

package/dist/commands/tasks/self-schedule.js

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.decisionClause = decisionClause;
+exports.describeSpentReturn = describeSpentReturn;
+exports.resolveRelativeRunAt = resolveRelativeRunAt;
+exports.resolveAbsoluteRunAt = resolveAbsoluteRunAt;
+exports.resolveRunAt = resolveRunAt;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const task_extras_1 = require("../../lib/task-extras");
@@ -20,6 +25,7 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
     static examples = [
         '<%= config.bin %> tasks self-schedule <task-id> --in 2h --note "check whether the deploy settled"',
         '<%= config.bin %> tasks self-schedule <task-id> --at 2026-09-09T14:00:00Z',
+        '<%= config.bin %> tasks self-schedule <task-id> --in 90m --re-enable',
         '<%= config.bin %> tasks self-schedule <task-id> --show',
         '<%= config.bin %> tasks self-schedule <task-id> --clear',
     ];
@@ -28,8 +34,14 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
-        at: core_1.Flags.string({ description: 'Absolute return time (ISO-8601 UTC)' }),
-        in: core_1.Flags.string({ description: 'Relative return time such as 90m, 2h, 3d' }),
+        at: core_1.Flags.string({
+            description: 'Absolute return time: ISO-8601 with a UTC offset, such as 2026-11-05T10:00:00Z or ' +
+                '2026-11-05T10:00:00-08:00',
+        }),
+        in: core_1.Flags.string({
+            description: 'Relative return time: a number with a unit (s, m, h, d), such as 90m, 1.5h or 3d. ' +
+                'A bare number means minutes. At least 60s, at most 14 days',
+        }),
         note: core_1.Flags.string({
             // This DOES reach the run now. It is read by `buildTaskExecutionPrompt`,
             // the one place every dispatch path assembles a task prompt, and rendered
@@ -40,7 +52,13 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
                 'prompt section, and readable any time with --show',
         }),
         'max-per-day': core_1.Flags.integer({
-            description: 'Cap on self-initiated returns per day (1-24, default 4)',
+            description: 'Cap on self-initiated returns per day (1-24). Omit to keep the cap this task ' +
+                'already has (4 for a task that never had one)',
+        }),
+        're-enable': core_1.Flags.boolean({
+            description: "Switch the task's return back on if it was turned off, then park it. Without this a " +
+                'switched-off return is left off and the park is refused. A person may; an agent only ' +
+                'where its initiative policy allows autonomous loops',
         }),
         show: core_1.Flags.boolean({ description: 'Print the pending return without changing it' }),
         clear: core_1.Flags.boolean({ description: 'Cancel the pending return' }),
@@ -61,20 +79,47 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
                 result = await task_extras_1.taskSelfScheduleApi.clear(taskRef);
             }
             else {
-                const runAt = resolveRunAt(flags.at, flags.in);
-                if (!runAt) {
+                const resolved = resolveRunAt(flags.at, flags.in);
+                if (!resolved) {
                     this.error('Pass --at <ISO-8601>, --in <duration>, or one of --show / --clear.', {
                         exit: 1,
                     });
                 }
+                if ('error' in resolved) {
+                    this.failWithCliError({
+                        message: resolved.error,
+                        code: 'INVALID_RETURN_TIME',
+                        exit: 1,
+                        retryable: false,
+                    });
+                }
+                // The server's field path, read back as the flag that wrote it.
+                this.requestFieldFlags = selfScheduleFieldFlags(Boolean(flags.at));
                 result = await task_extras_1.taskSelfScheduleApi.park(taskRef, {
-                    runAt,
+                    runAt: resolved.runAt,
                     ...(flags.note ? { note: flags.note } : {}),
-                    ...(flags['max-per-day'] ? { maxFiresPerDay: flags['max-per-day'] } : {}),
+                    // `!== undefined`, not truthiness: `--max-per-day 0` is a value the server
+                    // refuses (1-24), and dropping it here parked the task with the default
+                    // while printing a cap the person never asked for.
+                    ...(flags['max-per-day'] !== undefined ? { maxFiresPerDay: flags['max-per-day'] } : {}),
+                    ...(flags['re-enable'] ? { reEnable: true } : {}),
                 });
             }
         }
         catch (err) {
+            // A return someone switched off is left off. The server's sentence is the
+            // same for the web and the API; the CLI adds the flag that answers it.
+            if ((0, base_command_1.apiRefusal)(err).code === 'TASK_RETURN_DISABLED') {
+                this.failWithCliError({
+                    message: `Task ${taskRef}'s return is switched off, so it was not parked again.\n` +
+                        "→ Ask the task's owner to switch it back on in the task's Automations. A person " +
+                        'who means to turn it back on can run this command again with --re-enable.',
+                    code: 'TASK_RETURN_DISABLED',
+                    status: 409,
+                    exit: 1,
+                    retryable: false,
+                });
+            }
             this.handleApiError(err);
         }
         if (flags.json) {
@@ -82,15 +127,35 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
             return;
         }
         const runAt = result?.runAt;
+        const decision = result?.lastDecision;
         if (!runAt) {
             this.log(`Task ${taskRef} has no pending return.`);
+            // The interim tick clears the instant after a fire, so the decision may be
+            // all there is to say about the return that just went.
+            if (decision)
+                this.log(`Its last return ${decisionClause(decision)}.`);
             return;
         }
         // `pending` is derived server-side: a return that has already fired keeps
         // its instant on the row, and printing that verbatim would report a return
         // as upcoming an hour after it happened.
         const spent = result?.pending === false;
-        this.log(`Task ${taskRef} ${spent ? 'last returned at' : 'returns at'} ${runAt}`);
+        if (!spent) {
+            this.log(`Task ${taskRef} returns at ${runAt}`);
+        }
+        else {
+            // "Spent" only means the instant passed. Whether a run started is the
+            // decision's to say; "last returned at" was printed for returns that were
+            // skipped because the task was blocked, in review, done or archived.
+            const triggerId = result?.triggerId;
+            this.log(describeSpentReturn({
+                taskRef,
+                runAt,
+                decision,
+                triggerId: typeof triggerId === 'string' ? triggerId : undefined,
+                bin: this.config.bin,
+            }));
+        }
         if (result?.note)
             this.log(`Note: ${result.note}`);
         if (!spent && result?.maxFiresPerDay) {
@@ -99,20 +164,113 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
     }
 }
 exports.default = TasksSelfSchedule;
-/** `90m` / `2h` / `3d`, or an absolute instant. Absolute wins when both are given. */
-function resolveRunAt(at, relative) {
+/** The part after "the return came due and": what became of it, with the reason. */
+function decisionClause(decision) {
+    const why = decision.reasonText || decision.reason || decision.outcome || 'no reason was recorded';
+    switch (decision.verdict) {
+        case 'ran':
+            return 'started a run';
+        case 'failed':
+            return `could not be started: ${why}`;
+        case 'waiting':
+            return `has not started yet: ${why}`;
+        default:
+            return `was skipped: ${why}`;
+    }
+}
+/**
+ * The line `--show` prints for a return whose time has passed. "returned at" is
+ * said only when a run really started; a skipped, failed or unrecorded return
+ * says what it was.
+ */
+function describeSpentReturn({ taskRef, runAt, decision, triggerId, bin = 'skrr', }) {
+    if (decision?.verdict === 'ran')
+        return `Task ${taskRef} returned at ${runAt}`;
+    if (decision)
+        return `Task ${taskRef}: the return came due at ${runAt} and ${decisionClause(decision)}.`;
+    return (`Task ${taskRef}: the return came due at ${runAt}. Whether it ran is not recorded here; ` +
+        `\`${bin} triggers audit ${triggerId ?? `task-self-schedule:${taskRef}`}\` lists every fire.`);
+}
+/**
+ * Body paths the server may name in a refusal, and the flag that wrote each. `runAt`
+ * is written by whichever of --at / --in the person used, so a "runAt must be at
+ * least 60s in the future" for `--in 0m` is not read back as a flag they never typed.
+ */
+function selfScheduleFieldFlags(usedAt) {
+    return Object.freeze({
+        runAt: usedAt ? '--at' : '--in',
+        maxFiresPerDay: '--max-per-day',
+        note: '--note',
+    });
+}
+const MS_PER_UNIT = {
+    s: 1_000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+};
+/**
+ * A number, optionally fractional, with an optional unit. The unit words
+ * collapse onto their first character (`sec`/`secs`, `min`/`mins`, `hr`/`hrs`,
+ * `day`/`days`), which is unambiguous across the four units this accepts.
+ */
+const RELATIVE_PATTERN = /^(\d+(?:\.\d+)?|\.\d+)\s*(s|secs?|seconds?|m|mins?|minutes?|h|hrs?|hours?|d|days?)?$/i;
+/** What a person is told when `--in` is not a duration, in the words they would retype. */
+const RELATIVE_HELP = 'use a number with a unit (s, m, h or d), such as 90m, 1.5h or 3d. A bare number means minutes.';
+/**
+ * `--in` as an instant. A value that does not parse says WHICH value, because
+ * the generic "pass --at or --in" this used to fall through to told a person who
+ * had passed `--in 1.5h` to pass `--in`.
+ *
+ * Seconds are accepted: the server owns the 60 s floor and answers
+ * `RETURN_TOO_SOON` with the bound, which is a better explanation than the CLI
+ * refusing the unit.
+ */
+function resolveRelativeRunAt(relative, now = Date.now()) {
+    const match = RELATIVE_PATTERN.exec(relative.trim());
+    if (!match)
+        return { error: `--in ${relative}: ${RELATIVE_HELP}` };
+    const unit = (match[2] ?? 'm').toLowerCase()[0];
+    const ms = Math.round(Number(match[1]) * MS_PER_UNIT[unit]);
+    const at = new Date(now + ms);
+    if (!Number.isFinite(at.getTime())) {
+        return { error: `--in ${relative}: too far away. A return is at most 14 days out.` };
+    }
+    return { runAt: at.toISOString() };
+}
+/** An ISO-8601 date and time that names its zone: `Z`, or an offset such as `-08:00`. */
+const ISO_WITH_ZONE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}(?::?\d{2})?)$/i;
+/** The same shape with no zone, which is a real ISO-8601 value and an ambiguous instant. */
+const ISO_WITHOUT_ZONE = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?$/i;
+const ABSOLUTE_HELP = 'use an ISO-8601 date and time with a UTC offset, such as 2026-11-05T10:00:00Z or ' +
+    '2026-11-05T10:00:00-08:00.';
+/**
+ * `--at` as a UTC instant. Any offset is accepted and normalised, so the server
+ * always receives `...Z`. A value with no zone is refused by saying so: it is a
+ * valid ISO-8601 string, and "Invalid ISO datetime" for it read as if the CLI
+ * could not parse a thing the help had just told the person to type.
+ */
+function resolveAbsoluteRunAt(absolute) {
+    const value = absolute.trim();
+    if (ISO_WITH_ZONE.test(value)) {
+        const at = new Date(value);
+        if (Number.isFinite(at.getTime()))
+            return { runAt: at.toISOString() };
+        return { error: `--at ${absolute}: that is not a real date and time. ${ABSOLUTE_HELP}` };
+    }
+    if (ISO_WITHOUT_ZONE.test(value)) {
+        return {
+            error: `--at ${absolute}: no time zone, so the instant is ambiguous. Add Z for UTC or an ` +
+                'offset, such as 2026-11-05T10:00:00Z or 2026-11-05T10:00:00-08:00.',
+        };
+    }
+    return { error: `--at ${absolute}: not recognised as a date and time. ${ABSOLUTE_HELP}` };
+}
+/** `--at`, or `--in`, or neither (undefined). Absolute wins when both are given. */
+function resolveRunAt(at, relative, now = Date.now()) {
     if (at)
-        return at;
+        return resolveAbsoluteRunAt(at);
     if (!relative)
         return undefined;
-    const match = /^(\d+)\s*(m|min|mins|h|hr|hrs|d)$/i.exec(relative.trim());
-    if (!match)
-        return undefined;
-    const value = Number(match[1]);
-    const unit = match[2].toLowerCase();
-    const MS_PER_UNIT = { m: 60_000, h: 3_600_000, d: 86_400_000 };
-    // `min`/`mins`/`hr`/`hrs` collapse onto their first character, which is
-    // unambiguous across the three units this accepts.
-    const ms = value * (MS_PER_UNIT[unit[0]] ?? MS_PER_UNIT.h);
-    return new Date(Date.now() + ms).toISOString();
+    return resolveRelativeRunAt(relative, now);
 }

package/dist/lib/exec-runtime-binary.js

@@ -75,9 +75,10 @@ function forwardedFlagsNote(verb, opts = {}) {
     // daemon cannot silently end up on a different deployment than the CLI that
     // installed it (OSK-279). Saying so is the difference between a flag you may
     // pass and a flag that is already being passed for you.
+    const help = `${base} If \`skrrd\` is not on your PATH, use its installed path instead (typically \`~/.skrr/bin/skrrd\` on macOS and Linux).`;
     return opts.binds
-        ? `${base} \`--server\` and \`--profile\` are filled in from your CLI session unless you pass them.`
-        : base;
+        ? `${help} \`--server\` and \`--profile\` are filled in from your CLI session unless you pass them.`
+        : help;
 }
 /** Extra well-known install locations for one runtime name, checked after PATH. */
 function fallbackPathsForRuntime(name) {

package/dist/lib/harnesses.d.ts

@@ -243,7 +243,7 @@ export declare function forgetHarness(id: string): Promise<unknown>;
  * server (`pruneSupersededHarnesses.js`, `REASONS`) and worded once, in
  * `harnessPruneReasonSentence`, so the table and `--json` never disagree.
  */
-export type HarnessPruneReason = 'recent' | 'latest_registration' | 'no_live_sibling' | 'pinned' | 'granted' | 'default' | 'aliased' | 'changed_since_plan';
+export type HarnessPruneReason = 'recent' | 'latest_registration' | 'no_live_sibling' | 'has_usage' | 'pinned' | 'granted' | 'default' | 'aliased' | 'changed_since_plan';
 export interface HarnessPruneRow {
     id: string;
     daemonId: string | null;
@@ -257,6 +257,8 @@ export interface HarnessPruneRow {
         daemonId: string | null;
         lastSeenAt: string | null;
     };
+    /** The gone lease a row this call removes (or would) belonged to (`--include-gone-leases`). */
+    goneLease?: string;
     /** Set on kept rows. */
     reason?: HarnessPruneReason;
     /** For `pinned`: who holds the pin. Other people's agents are a count, never named. */
@@ -300,6 +302,7 @@ export declare function pruneHarnesses(options?: {
     dryRun: boolean;
     limit?: number;
     minUnseenMs?: number;
+    includeGoneLeases?: boolean;
 }): Promise<HarnessPruneResult>;
 /**
  * `--older-than` takes a whole number with a unit: `90m`, `36h`, `7d`. A bare

package/dist/lib/harnesses.js

@@ -192,6 +192,7 @@ async function pruneHarnesses(options = { dryRun: true }) {
             dryRun: options.dryRun,
             ...(options.limit !== undefined ? { limit: options.limit } : {}),
             ...(options.minUnseenMs !== undefined ? { minUnseenMs: options.minUnseenMs } : {}),
+            ...(options.includeGoneLeases ? { includeGoneLeases: true } : {}),
         },
     });
 }
@@ -219,6 +220,8 @@ function harnessPruneReasonSentence(row) {
             return 'the newest registration of its provider on that machine';
         case 'no_live_sibling':
             return 'nothing has replaced it - no daemon on that machine is online for this provider';
+        case 'has_usage':
+            return 'usage is recorded against it, so the row keeps the name that usage is attributed to';
         case 'pinned': {
             const names = (row.detail?.agents ?? []).map((a) => a.name ?? a.id);
             const more = row.detail?.moreAgents ?? 0;

package/dist/lib/northstars.d.ts

@@ -1,7 +1,8 @@
-import { NORTHSTAR_ANALYSIS_MODES, NORTHSTAR_APPROVAL_TRIGGERS, NORTHSTAR_EXECUTION_MODES, NORTHSTAR_INTENT_VERDICTS, NORTHSTAR_MANAGEMENT_INTENT_KINDS, NORTHSTAR_REVIEW_STATUSES } from '@skrr-ai/data-provider';
+import { NORTHSTAR_ANALYSIS_MODES, NORTHSTAR_APPROVAL_TRIGGERS, NORTHSTAR_EXECUTION_MODES, NORTHSTAR_INTENT_VERDICTS, NORTHSTAR_MANAGEMENT_INTENT_KINDS, NORTHSTAR_REASON_WORDS, NORTHSTAR_REVIEW_STATUSES, describeNorthstarReason } from '@skrr-ai/data-provider';
 import type { Northstar, NorthstarAnalysisMode, NorthstarExecutionMode, NorthstarGovernance, NorthstarGovernanceStatus, NorthstarGovernanceUpdateParams, NorthstarListResponse, NorthstarManagementIntent, NorthstarManagementIntentKind, NorthstarRecommendation, NorthstarReviewRecord, NorthstarStatusResponse } from '@skrr-ai/data-provider';
 import { withQuery } from './triggers';
 export { NORTHSTAR_ANALYSIS_MODES, NORTHSTAR_APPROVAL_TRIGGERS, NORTHSTAR_EXECUTION_MODES, NORTHSTAR_INTENT_VERDICTS, NORTHSTAR_MANAGEMENT_INTENT_KINDS, NORTHSTAR_REVIEW_STATUSES, };
+export { NORTHSTAR_REASON_WORDS, describeNorthstarReason };
 export type { Northstar, NorthstarAnalysisMode, NorthstarExecutionMode, NorthstarGovernance, NorthstarGovernanceStatus, NorthstarManagementIntent, NorthstarManagementIntentKind, NorthstarRecommendation, NorthstarReviewRecord, };
 /**
  * oclif's `options:` needs runtime arrays, and these two are LIFECYCLE
@@ -72,9 +73,6 @@ export declare function lookupReview(northstarId: string, typed: string): Promis
 /** ms → a short human duration, for a table cell that must stay narrow. */
 export declare function humanMs(ms?: number): string;
 export declare function shortDate(value?: string): string;
-export declare const NORTHSTAR_REASON_WORDS: Readonly<Record<string, string>>;
-/** A code in words; an unknown code comes back unchanged, an absent one says so. */
-export declare function describeNorthstarReason(code: string | null | undefined): string;
 export type NorthstarDecisionContext = {
     northstarId: string;
     intentId: string;
@@ -131,6 +129,48 @@ export declare function listFooter(input: {
     nextCursor?: string | null;
     cursor?: boolean;
 }): string;
+/** What a northstar with no workspace is called wherever a workspace is named. */
+export declare const PERSONAL_NORTHSTAR_WORKSPACE = "personal";
+/** Why a personal northstar can look missing on the web. The one sentence the others build on. */
+export declare const NORTHSTAR_WEB_SCOPE_SENTENCE: string;
+/** Help text shared by `list` and `show`: where a northstar's workspace is printed. */
+export declare const NORTHSTAR_WORKSPACE_READ_HELP: string;
+/** Help text for `create`: which workspace it lands in, and how to choose one. */
+export declare const NORTHSTAR_WORKSPACE_CREATE_HELP: string;
+/**
+ * Anything that may carry a `workspaceId`: a typed Northstar, or the raw record `create` prints (it
+ * is read through `Record<string, unknown>` so `--json` is the server's body plus the url).
+ */
+type WorkspaceBearing = {
+    workspaceId?: unknown;
+} | Record<string, unknown>;
+export declare function shortWorkspaceId(id: string): string;
+/** The workspace a northstar lives in, in one word or id: `personal` when it has none. */
+export declare function northstarWorkspaceLabel(northstar: WorkspaceBearing, options?: {
+    short?: boolean;
+}): string;
+/** The line `show` and `create` print: the full workspace id, or `personal`. */
+export declare function northstarWorkspaceLine(northstar: WorkspaceBearing): string;
+/** What the process that ran `create` asked for: the inputs to which note a personal northstar gets. */
+export type PersonalNorthstarContext = {
+    /** An Agent session: its workspace comes from the session, and `--workspace` is ignored. */
+    autonomous?: boolean;
+    /** The workspace the request carried (`--workspace`, or the one `workspaces use` chose). */
+    requestedWorkspaceId?: string;
+};
+/**
+ * What `create` adds when the northstar landed in no workspace. Three causes, three endings:
+ *
+ *   - an Agent session takes its workspace from the session and ignores `--workspace`, so telling
+ *     it to pass the flag would send it round in a circle;
+ *   - a workspace WAS requested but the person is not a member of it: the server does not refuse,
+ *     it creates the northstar personal (`resolveWorkspaceContext`), so "pass --workspace" would
+ *     be said to someone who just did;
+ *   - nothing was requested, and the way out is the flag.
+ */
+export declare function personalNorthstarNote(context?: PersonalNorthstarContext): string;
+/** The note for a northstar `create` just made: nothing when it is in a workspace. */
+export declare function createdNorthstarNote(northstar: WorkspaceBearing, context?: PersonalNorthstarContext): string | undefined;
 export declare function renderNorthstarList(rows: Northstar[], log: (line: string) => void): void;
 /**
  * The active-commitment cap, in words. `0` is accepted and stored, and a review