@tt-a1i/openpi 0.1.0

package/extensions/shared/context-utilization.ts

@@ -0,0 +1,47 @@
+/** Compact, defensive context-window utilization formatting for child agents. */
+
+export interface ContextUtilization {
+  /** Current conversation context occupancy; null while it is unknown after compaction. */
+  tokens?: number | null;
+  /** Capacity of the model currently serving the conversation. */
+  contextWindow?: number | null;
+}
+
+function usableTokens(value: number | null | undefined) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0
+    ? value
+    : undefined;
+}
+
+function usableCapacity(value: number | null | undefined) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0
+    ? value
+    : undefined;
+}
+
+export function contextPercent(usage: ContextUtilization) {
+  const tokens = usableTokens(usage.tokens);
+  const capacity = usableCapacity(usage.contextWindow);
+  if (tokens === undefined || capacity === undefined) return undefined;
+  return Math.round(Math.min(100, Math.max(0, (tokens / capacity) * 100)));
+}
+
+export function formatCompactTokens(count: number) {
+  if (count < 1000) return Math.round(count).toString();
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1000000) return `${Math.round(count / 1000)}k`;
+  return `${(count / 1000000).toFixed(1)}M`;
+}
+
+/**
+ * Render `%/capacity`. If occupancy is temporarily unknown (notably directly
+ * after compaction), retain the useful model capacity as `?%/capacity`. If no
+ * valid capacity is available, omit the statistic because no percentage can
+ * be computed.
+ */
+export function formatContextUtilization(usage: ContextUtilization) {
+  const capacity = usableCapacity(usage.contextWindow);
+  if (capacity === undefined) return "";
+  const percent = contextPercent(usage);
+  return `${percent === undefined ? "?" : percent}%/${formatCompactTokens(capacity)}`;
+}

package/extensions/shared/dashboard-state.ts

@@ -0,0 +1,102 @@
+export const MODEL_INFO_CHANNEL = "dashboard:model-info";
+export const GIT_INFO_CHANNEL = "dashboard:git-info";
+export const REFRESH_CHANNEL = "dashboard:refresh";
+
+export interface ModelInfoState {
+  provider: string;
+  modelId: string;
+  modelName: string;
+  thinking: string;
+  contextTokens: number | null;
+  contextWindow: number;
+  contextPercent: number | null;
+  cachePercent: number | null;
+  cost: number;
+  tokensPerSecond: number | null;
+  generating: boolean;
+}
+
+export interface PullRequestInfo {
+  number: number;
+  url: string;
+  isDraft: boolean;
+}
+
+export interface GitInfoState {
+  isRepository: boolean;
+  branch: string | null;
+  changedFiles: number;
+  pullRequest: PullRequestInfo | null;
+}
+
+export function emptyModelInfoState(): ModelInfoState {
+  return {
+    provider: "",
+    modelId: "no-model",
+    modelName: "No model",
+    thinking: "off",
+    contextTokens: null,
+    contextWindow: 0,
+    contextPercent: null,
+    cachePercent: null,
+    cost: 0,
+    tokensPerSecond: null,
+    generating: false,
+  };
+}
+
+export function emptyGitInfoState(): GitInfoState {
+  return {
+    isRepository: false,
+    branch: null,
+    changedFiles: 0,
+    pullRequest: null,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isNullableNumber(value: unknown) {
+  return value === null || typeof value === "number";
+}
+
+export function isModelInfoState(value: unknown): value is ModelInfoState {
+  if (!isRecord(value)) return false;
+
+  return (
+    typeof value.provider === "string" &&
+    typeof value.modelId === "string" &&
+    typeof value.modelName === "string" &&
+    typeof value.thinking === "string" &&
+    isNullableNumber(value.contextTokens) &&
+    typeof value.contextWindow === "number" &&
+    isNullableNumber(value.contextPercent) &&
+    isNullableNumber(value.cachePercent) &&
+    typeof value.cost === "number" &&
+    isNullableNumber(value.tokensPerSecond) &&
+    typeof value.generating === "boolean"
+  );
+}
+
+function isPullRequestInfo(value: unknown): value is PullRequestInfo {
+  if (!isRecord(value)) return false;
+
+  return (
+    typeof value.number === "number" &&
+    typeof value.url === "string" &&
+    typeof value.isDraft === "boolean"
+  );
+}
+
+export function isGitInfoState(value: unknown): value is GitInfoState {
+  if (!isRecord(value)) return false;
+
+  return (
+    typeof value.isRepository === "boolean" &&
+    (value.branch === null || typeof value.branch === "string") &&
+    typeof value.changedFiles === "number" &&
+    (value.pullRequest === null || isPullRequestInfo(value.pullRequest))
+  );
+}

package/extensions/shared/plan-mode-state.ts

@@ -0,0 +1,65 @@
+/**
+ * The read-only stance `/plan` puts a session in, shared between the extension
+ * that owns it (plan-mode) and the extensions that must honour it (subagents).
+ *
+ * Why a shared module rather than a check inside plan-mode: a `tool_call`
+ * handler only sees THIS session, and a subagent runs in its own. Blocking
+ * delegation outright was the first answer and it was wrong — exploring a
+ * codebase across several subsystems in parallel, without dragging the noise
+ * into the main context, is one of the most useful things to do while
+ * planning. What makes it safe is that the child tool allowlist is enforced by
+ * the harness, not by prompt: a child spawned with these tools has no `write`,
+ * `edit`, or `bash` to call, so it cannot break the promise that nothing
+ * changes before the user approves.
+ */
+
+/**
+ * Tools a child may keep while the parent is planning. Investigation only:
+ * anything that mutates a file, runs a command, or reaches the network is
+ * absent, and unknown tools (including a third party's) are excluded by the
+ * allowlist being an allowlist.
+ *
+ * `bash` is absent even though plan mode admits read-only commands in the
+ * parent: that gate reads the command string, and nothing here can inspect
+ * what a child would run before it runs it.
+ */
+export const PLAN_MODE_CHILD_TOOLS: readonly string[] = [
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "fd",
+  "rg",
+];
+
+/** Broadcast when the session's planning stance changes. */
+export const PLAN_MODE_CHANNEL = "my-pi-setup:plan-mode";
+
+export interface PlanModeState {
+  /** True while `/plan` is armed and nothing may change yet. */
+  readonly planning: boolean;
+}
+
+/**
+ * Narrow an agent type's allowlist to what planning permits.
+ *
+ * Intersects rather than replaces, so a type that already restricts itself
+ * further keeps its own limit: planning may only ever REMOVE capability, never
+ * hand a child something its type withheld.
+ */
+export function planModeChildTools(
+  requested: readonly string[] | undefined,
+): readonly string[] {
+  if (!requested) return [...PLAN_MODE_CHILD_TOOLS];
+  return requested.filter((tool) => PLAN_MODE_CHILD_TOOLS.includes(tool));
+}
+
+/** Whether a selected type can run unchanged under plan mode. */
+export function planModeAllowsDeclaredTools(tools?: readonly string[]) {
+  // Omitting `tools` inherits the normal write-capable child set, so selecting
+  // that type would still pair its unchanged prompt with narrowed capabilities.
+  return (
+    tools !== undefined &&
+    tools.every((tool) => PLAN_MODE_CHILD_TOOLS.includes(tool))
+  );
+}